SmythOS Studio: Open-Source Visual AI Agent Builder and deployable runtime stack from SmythOS. Start with an intuitive drag-and-drop workspace, extend with custom code, and deploy your agents anywhere — local, cloud, or edge — with full governance and control.
JavaScript a2aagentic-aiai-agentsdevtoolsmcp-clientn8n-alternativeno-codeopen-sourceorchestrationsmythosvisual-builder
refactor multi selectbox function
Forhad Hosain93bf35a0a16c
diff --git a/packages/app/src/builder-ui/ui/form/fields.ts b/packages/app/src/builder-ui/ui/form/fields.bak.tssimilarity index 83%rename from packages/app/src/builder-ui/ui/form/fields.tsrename to packages/app/src/builder-ui/ui/form/fields.bak.tsindex 9d60cf42..d0d45361 100644--- a/packages/app/src/builder-ui/ui/form/fields.ts+++ b/packages/app/src/builder-ui/ui/form/fields.bak.ts@@ -245,352 +245,6 @@ export const createSelectBox = (return select;};-/**- * Creates a simple, user-friendly multi-select with checkboxes and visual chips- * This uses native HTML5 elements without Metro UI- * Features:- * - Search input to filter options- * - Checkboxes for easy selection (simple click, no Ctrl/Cmd needed)- * - Visual chips showing selected items- * - Hidden select element for form compatibility- * @param options - Array of option objects with text and value properties- * @param value - Array of selected values- * @param dropdownHeight - Optional height for the options list in pixels- * @returns HTMLDivElement containing the complete multi-select UI- */-export const createMultiSelectBox = (- options: Array<{ value: string; text: string }> | any,- value: string[],- dropdownHeight?: number,-): HTMLDivElement => {- /**- * Main container - position relative for absolute positioning of dropdown- */- const container = document.createElement('div');- container.classList.add('multi-select-container');- container.style.cssText = 'display: flex; flex-direction: column; gap: 8px; position: relative;';-- /**- * Selected items display area (chips/tags) with caret- */- const selectedChipsWrapper = document.createElement('div');- selectedChipsWrapper.style.cssText = 'position: relative; display: flex; align-items: center;';-- const selectedChips = document.createElement('div');- selectedChips.classList.add('multi-select-chips');- selectedChips.style.cssText =- 'display: flex; flex-wrap: wrap; gap: 6px; min-height: 36px; padding: 6px 32px 6px 6px; border: 1px solid #d1d5db; border-radius: 6px; background: #f9fafb; flex: 1; cursor: pointer; transition: background-color 0.15s ease;';- selectedChips.innerHTML =- '<span style="color: #9ca3af; font-size: 14px;">No items selected</span>';-- /**- * Add hover effect to chips area- */- selectedChips.addEventListener('mouseenter', () => {- selectedChips.style.backgroundColor = '#f3f4f6';- });- selectedChips.addEventListener('mouseleave', () => {- selectedChips.style.backgroundColor = '#f9fafb';- });-- /**- * Caret/dropdown icon (inside selected chips area)- */- const caretIcon = document.createElement('span');- caretIcon.classList.add('multi-select-caret');- caretIcon.innerHTML = '▼';- caretIcon.style.cssText =- 'position: absolute; right: 10px; font-size: 12px; color: #6b7280; pointer-events: none; transition: transform 0.2s ease;';-- /**- * Dropdown wrapper - contains search input and options list- * Positioned absolutely to float over other content- */- const dropdownWrapper = document.createElement('div');- dropdownWrapper.classList.add('multi-select-dropdown');- dropdownWrapper.style.cssText =- 'position: absolute; top: 100%; left: 0; right: 0; z-index: 1000; margin-top: 4px; display: none; flex-direction: column; gap: 8px; background: white; border: 1px solid #d1d5db; border-radius: 6px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); padding: 8px;';-- /**- * Search input for filtering options- */- const searchInput = document.createElement('input');- searchInput.type = 'text';- searchInput.placeholder = 'Search options...';- searchInput.classList.add('multi-select-search', 'form-control');- searchInput.style.cssText =- 'padding: 8px; border-radius: 6px; border: 1px solid #d1d5db; width: 100%;';-- /**- * Options list container with checkboxes- */- const optionsList = document.createElement('div');- optionsList.classList.add('multi-select-options');- const height = dropdownHeight || 200;- optionsList.style.cssText = `max-height: ${height}px; overflow-y: auto; border-radius: 6px; background: white;`;-- /**- * Hidden select element for form compatibility- * This stores the actual selected values for form submission- */- const hiddenSelect = document.createElement('select');- hiddenSelect.setAttribute('multiple', 'multiple');- hiddenSelect.style.display = 'none';- hiddenSelect.classList.add('multi-select-native');-- /**- * Store all options and selected values- */- let allOptions: Array<{ value: string; text: string }> = [];- const selectedValues = new Set<string>(Array.isArray(value) ? value : []);-- /**- * Create a chip element for a selected item- */- const createChip = (optionValue: string, optionText: string): HTMLElement => {- const chip = document.createElement('span');- chip.style.cssText =- 'display: inline-flex; align-items: center; gap: 4px; padding: 4px 8px; background: #3b82f6; color: white; border-radius: 4px; font-size: 14px;';- chip.innerHTML = `- ${optionText}- <button type="button" style="background: none; border: none; color: white; cursor: pointer; font-size: 16px; line-height: 1; padding: 0; margin-left: 4px;" data-value="${optionValue}">×</button>- `;-- // Remove chip on click- const removeBtn = chip.querySelector('button') as HTMLButtonElement;- removeBtn.addEventListener('click', (e) => {- e.preventDefault();- e.stopPropagation();- const val = removeBtn.getAttribute('data-value');- if (val) {- selectedValues.delete(val);- updateUI();- // Trigger change event- hiddenSelect.dispatchEvent(new Event('change', { bubbles: true }));- }- });-- return chip;- };-- /**- * Update the UI based on selected values- */- const updateUI = (): void => {- // Update chips display- selectedChips.innerHTML = '';- if (selectedValues.size === 0) {- selectedChips.innerHTML =- '<span style="color: #9ca3af; font-size: 14px;">No items selected</span>';- } else {- selectedValues.forEach((val) => {- const option = allOptions.find((opt) => opt.value === val);- if (option) {- selectedChips.appendChild(createChip(option.value, option.text));- }- });- }-- // Update hidden select- hiddenSelect.innerHTML = '';- selectedValues.forEach((val) => {- const option = document.createElement('option');- option.value = val;- option.selected = true;- hiddenSelect.appendChild(option);- });-- // Update checkmark icons in the options list- const optionItems = optionsList.querySelectorAll('[data-value]');- optionItems.forEach((item) => {- const value = item.getAttribute('data-value');- const checkmark = item.querySelector('.checkmark-icon') as HTMLElement;- if (checkmark && value) {- checkmark.style.display = selectedValues.has(value) ? 'inline-block' : 'none';- }- });- };-- /**- * Create option element with checkmark icon- */- const createOptionElement = (option: { value: string; text: string }): HTMLElement => {- const isSelected = selectedValues.has(option.value);-- const label = document.createElement('div');- label.style.cssText =- 'display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; cursor: pointer; user-select: none; border-bottom: 1px solid #f3f4f6;';- label.setAttribute('data-value', option.value);-- label.innerHTML = `- <span style="font-size: 14px;">${option.text}</span>- <span class="checkmark-icon" style="font-size: 18px; color: #10b981; font-weight: bold; display: ${isSelected ? 'inline-block' : 'none'};">✓</span>- `;-- // Handle click to toggle selection- label.addEventListener('click', () => {- const value = label.getAttribute('data-value');- if (!value) return;-- const checkmark = label.querySelector('.checkmark-icon') as HTMLElement;-- if (selectedValues.has(value)) {- selectedValues.delete(value);- checkmark.style.display = 'none';- } else {- selectedValues.add(value);- checkmark.style.display = 'inline-block';- }-- updateUI();- // Trigger change event on hidden select- hiddenSelect.dispatchEvent(new Event('change', { bubbles: true }));- });-- // Hover effect- label.addEventListener('mouseenter', () => {- label.style.background = '#f3f4f6';- });- label.addEventListener('mouseleave', () => {- label.style.background = 'white';- });-- return label;- };-- /**- * Populate options list with optional filtering- */- const populateOptions = (filterText: string = ''): void => {- optionsList.innerHTML = '';-- const filtered = filterText- ? allOptions.filter(- (option) =>- option.text.toLowerCase().includes(filterText.toLowerCase()) ||- option.value.toLowerCase().includes(filterText.toLowerCase()),- )- : allOptions;-- if (filtered.length === 0) {- optionsList.innerHTML =- '<div style="padding: 12px; text-align: center; color: #9ca3af;">No options found</div>';- } else {- filtered.forEach((option) => {- optionsList.appendChild(createOptionElement(option));- });- }- };-- /**- * Toggle dropdown visibility- */- let isOpen = false;- const toggleDropdown = (): void => {- isOpen = !isOpen;- dropdownWrapper.style.display = isOpen ? 'flex' : 'none';- caretIcon.style.transform = isOpen ? 'rotate(180deg)' : 'rotate(0deg)';-- // Focus search input when opening- if (isOpen) {- setTimeout(() => searchInput.focus(), 100);- } else {- searchInput.value = '';- populateOptions('');- }- };-- /**- * Set up selected chips click handler to toggle dropdown- */- selectedChips.addEventListener('click', (e) => {- // Don't toggle if clicking on remove button- const target = e.target as HTMLElement;- if (target.tagName === 'BUTTON' || target.closest('button')) {- return;- }- e.stopPropagation();- toggleDropdown();- });-- /**- * Set up search input for filtering- */- searchInput.addEventListener('input', (e) => {- const target = e.target as HTMLInputElement;- populateOptions(target.value);- });-- /**- * Prevent closing when clicking on search input- */- searchInput.addEventListener('click', (e) => {- e.stopPropagation();- });-- /**- * Close dropdown when clicking outside- */- document.addEventListener('click', (e) => {- if (!container.contains(e.target as Node) && isOpen) {- toggleDropdown();- }- });-- /**- * Handle async or sync options- */- if (typeof options === 'function') {- setTimeout(() => {- const formBox = container.closest('.form-box');- if (formBox) formBox.classList.add('loading');- }, 300);-- options().then((data: Array<{ value: string; text: string }>) => {- allOptions = data;- populateOptions();- updateUI();-- const formBox = container.closest('.form-box');- if (formBox) {- setTimeout(() => {- formBox.classList.remove('loading');- }, 300);- }- });- } else {- allOptions = options;- populateOptions();- updateUI();- }-- /**- * Assemble the selected chips wrapper- */- selectedChipsWrapper.appendChild(selectedChips);- selectedChipsWrapper.appendChild(caretIcon);-- /**- * Assemble the dropdown wrapper (floating)- */- dropdownWrapper.appendChild(searchInput);- dropdownWrapper.appendChild(optionsList);-- /**- * Assemble the container- */- container.appendChild(selectedChipsWrapper);- container.appendChild(dropdownWrapper);- container.appendChild(hiddenSelect);-- /**- * Store reference to the hidden select element for form handling- */- (container as any)._selectElement = hiddenSelect;-- return container;-};-export const createCheckbox = (label: string, value: string): HTMLInputElement => {const checkbox = document.createElement('input');checkbox.setAttribute('data-role', 'checkbox');diff --git a/packages/app/src/builder-ui/ui/form/fields/index.ts b/packages/app/src/builder-ui/ui/form/fields/index.tsnew file mode 100644index 00000000..31ecc4d4--- /dev/null+++ b/packages/app/src/builder-ui/ui/form/fields/index.ts@@ -0,0 +1,1658 @@+import {+ Tooltip,+ TooltipContent,+ TooltipProvider,+ TooltipTrigger,+} from '@src/react/shared/components/ui/tooltip';+import DOMPurify from 'dompurify';+import React from 'react';+import { createRoot } from 'react-dom/client';+import { delay } from '../../../utils';+import { handleKvFieldEditBtn, handleVaultBtn } from '../../../utils/component.utils';+import { addBracketSelection, handleTemplateVars } from '../misc';++declare var Metro;++/**+ * Helper function to check if vault button should be shown based on dynamic conditions+ * @param vaultCondition - The condition configuration+ * @param contentType - Fallback content type for backward compatibility+ * @returns boolean indicating whether vault button should be shown+ */+function shouldShowVaultButton(+ vaultCondition?: { property: string; value: string; getValue?: () => string },+ contentType?: string,+): boolean {+ // If no vault condition is provided, use legacy contentType logic+ if (!vaultCondition) {+ return contentType === 'application/json';+ }++ try {+ // Try to get the value using the custom getValue function first+ if (vaultCondition.getValue) {+ const currentValue = vaultCondition.getValue();+ return currentValue === vaultCondition.value;+ }++ // Fallback: try to get value from DOM element+ const element = document.querySelector(`#${vaultCondition.property}`) as+ | HTMLSelectElement+ | HTMLInputElement;+ if (element) {+ return element.value === vaultCondition.value;+ }++ // Fallback: try to get value from component data+ const currentComponent = (window as any).Component?.curComponentSettings;+ if (currentComponent?.data?.[vaultCondition.property]) {+ return currentComponent.data[vaultCondition.property] === vaultCondition.value;+ }++ return false;+ } catch (error) {+ console.warn('Error checking vault condition:', error);+ return false;+ }+}++/**+ * Global registry for datalist options.+ * Options are stored as functions to avoid loading large data modules during app initialization.+ * The functions are called synchronously on first focus to ensure immediate availability.+ */+const datalistRegistry: Map<string, () => Array<string | { text: string; value: string }>> =+ new Map();++/**+ * Register a datalist options provider by datalist ID.+ * The provider function is called synchronously when the field is first focused.+ *+ * @param datalistId - Unique ID for the datalist+ * @param optionsProvider - Function that returns the options array+ */+export const registerDatalistOptions = (+ datalistId: string,+ optionsProvider: () => Array<string | { text: string; value: string }>,+): void => {+ datalistRegistry.set(datalistId, optionsProvider);+};++export const createInput = (value: string = ''): HTMLInputElement => {+ const fieldElm = document.createElement('input');+ fieldElm.setAttribute('data-role', 'input');+ fieldElm.setAttribute('value', value || '');++ return fieldElm;+};++export const createHiddenInput = (value: string = ''): HTMLInputElement => {+ const fieldElm = document.createElement('input');+ fieldElm.setAttribute('type', 'hidden');+ fieldElm.setAttribute('value', value || '');++ return fieldElm;+};++/**+ * Creates a text input with datalist autocomplete support.+ * The datalist is created synchronously on first user interaction (mousedown, touchstart, or focus).+ * Using mousedown ensures the datalist is ready BEFORE focus, making it work on the first try.+ * This keeps initial render fast while ensuring the field works immediately.+ *+ * @param value - Initial value for the input+ * @param datalistId - ID for the datalist element (used to lookup options in registry)+ * @returns HTMLInputElement with datalist support+ */+export const createDatalistInput = (value: string = '', datalistId?: string): HTMLInputElement => {+ const fieldElm = document.createElement('input');+ fieldElm.setAttribute('data-role', 'input');+ fieldElm.setAttribute('type', 'text');+ fieldElm.setAttribute('value', value || '');++ // Set up datalist if datalistId is provided+ if (datalistId) {+ fieldElm.setAttribute('list', datalistId);++ let datalistCreated = false;++ // Create datalist on first interaction - synchronously so it's ready immediately+ const createDatalistOnce = (): void => {+ // Prevent multiple calls+ if (datalistCreated) {+ return;+ }++ // Check if datalist already exists+ if (document.getElementById(datalistId)) {+ datalistCreated = true;+ return;+ }++ // Get options provider from registry+ const optionsProvider = datalistRegistry.get(datalistId);+ if (!optionsProvider) {+ console.warn(`Datalist options not registered for ID: ${datalistId}`);+ datalistCreated = true;+ return;+ }++ // Create datalist SYNCHRONOUSLY (no setTimeout/requestIdleCallback)+ // This ensures the datalist exists before the browser tries to show the dropdown+ const options = optionsProvider();++ const datalist = document.createElement('datalist');+ datalist.id = datalistId;++ // Use DocumentFragment for batch DOM operations (much faster)+ const fragment = document.createDocumentFragment();++ options.forEach((option) => {+ const optionEl = document.createElement('option');+ if (typeof option === 'string') {+ optionEl.value = option;+ } else {+ optionEl.value = option.value;+ if (option.text) {+ optionEl.textContent = option.text;+ }+ }+ fragment.appendChild(optionEl);+ });++ datalist.appendChild(fragment);+ document.body.appendChild(datalist);+ datalistCreated = true;+ };++ // Listen to multiple events to catch interaction as early as possible+ // mousedown fires BEFORE focus, ensuring datalist is ready+ fieldElm.addEventListener('mousedown', createDatalistOnce, { once: true });+ fieldElm.addEventListener('focus', createDatalistOnce, { once: true });+ // Also handle touch devices+ fieldElm.addEventListener('touchstart', createDatalistOnce, { once: true, passive: true });+ }++ return fieldElm;+};++/*+ * Note:+ * Currently, the 'options()' function does not support badges. To enable this feature,+ * maybe we can extend the 'addOption()' function in 'static/metroui/js/metro.js' at line #30083.+ */+export const createSelectBox = (+ options: Array<{ value: string; text: string }> | any,+ value: string,+ dropdownHeight?: number,+): HTMLSelectElement => {+ const select = document.createElement('select');+ select.setAttribute('data-role', 'select');++ if (dropdownHeight) {+ select.setAttribute('data-drop-height', `${dropdownHeight}`);+ }++ let entries = [];++ //get options from function+ if (typeof options === 'function') {+ setTimeout(() => {+ const div = select.closest('.form-box');+ if (div) div.classList.add('loading');+ }, 300);+ options().then((data) => {+ entries = data;++ const selectElem = Metro.getPlugin(select, 'select');+ selectElem.removeOptions([...selectElem?.elem?.options].map((o) => o.value)); //remove all options+ data.forEach((option) => {+ const _text = option.text !== undefined ? option.text : option?.value || option; // handle empty string ''+ const _value = option.value !== undefined ? option.value : option; // handle empty string ''+ const _selected = value == _value;+ selectElem.addOption(_value, _text, _selected);+ });++ const div = select.closest('.form-box');+ if (div) {+ setTimeout(() => {+ div.classList.remove('loading');+ }, 300);+ }+ });+ } else {+ entries = options;+ }++ //create the default select element, leave it empty if no value is provided or if we're fetching options from a function+ select.innerHTML = entries+ .map((option) => {+ const _text = option.text !== undefined ? option.text : option?.value || option; // handle empty string ''+ const _value = option.value !== undefined ? option.value : option; // handle empty string ''+ const _badge = option?.badge || '';+ let template = '';++ if (_badge) {+ template = `data-template="$1 ${_badge.replace(/\"/g, `'`)}"`;+ }++ return `<option value="${_value}" ${+ value == _value ? 'selected' : ''+ } ${template}>${_text}</option>`;+ })+ .join('');++ return select;+};++// Re-export createMultiSelectBox from separate module+export { createMultiSelectBox } from './multiSelectBox.field';++export const createCheckbox = (label: string, value: string): HTMLInputElement => {+ const checkbox = document.createElement('input');+ checkbox.setAttribute('data-role', 'checkbox');+ checkbox.setAttribute('type', 'checkbox');+ checkbox.setAttribute('data-caption', label);+ //formElement.setAttribute('data-caption-position', 'left');+ if (value) checkbox.setAttribute('checked', '');+ else checkbox.removeAttribute('checked');++ return checkbox;+};++export const createCheckboxGroup = (+ options: Array<{ value: string; text: string; checked: boolean; readonly: boolean }>,+ value: string[],+): HTMLDivElement => {+ const group = document.createElement('div');+ group.setAttribute('data-role', 'checkbox-group');++ // value example: ['1', '2']+ group.innerHTML = options+ .map((option) => {+ const checkbox = document.createElement('input');+ checkbox.setAttribute('data-role', 'checkbox');+ checkbox.setAttribute('type', 'checkbox');+ checkbox.setAttribute('data-caption', option.text);+ checkbox.setAttribute('value', option.value);++ if ((value && Array.isArray(value) && value.includes(option.value)) || option?.checked) {+ checkbox.setAttribute('checked', 'checked');+ }++ if (option?.readonly) {+ checkbox.setAttribute('disabled', 'disabled');+ }++ return checkbox.outerHTML;+ })+ .join('');++ return group;+};++/**+ * Type definition for textarea elements with an attached code editor instance+ */+interface TextAreaWithEditor extends HTMLTextAreaElement {+ _editor?: {+ getValue: () => string;+ setValue: (value: string) => void;+ focus: () => void;+ container?: HTMLElement;+ setOption?: (option: string, value: number | boolean | null) => void;+ resize?: (force: boolean) => void;+ };+}++/**+ * Shared code editor configuration type+ */+type CodeConfig = { mode?: string; theme?: string; disableWorker?: boolean };++/**+ * Cached imports for modal and editor functionality to avoid repeated dynamic imports+ */+let cachedTwModalDialog: typeof import('../../tw-dialogs').twModalDialog | null = null;+let cachedSetCodeEditor: typeof import('../../dom').setCodeEditor | null = null;++/**+ * Lazy load and cache modal-related imports+ * This avoids circular dependencies while maintaining performance+ * Imports are cached separately to handle both code editor and non-code editor cases+ */+async function getModalImports(needsCodeEditor: boolean): Promise<{+ twModalDialog: typeof import('../../tw-dialogs').twModalDialog;+ setCodeEditor: typeof import('../../dom').setCodeEditor | null;+}> {+ // Load dialog module if not cached+ if (!cachedTwModalDialog) {+ const dialogModule = await import('../../tw-dialogs');+ cachedTwModalDialog = dialogModule.twModalDialog;+ }++ // Load code editor module if needed and not cached+ if (needsCodeEditor && !cachedSetCodeEditor) {+ const domModule = await import('../../dom');+ cachedSetCodeEditor = domModule.setCodeEditor;+ }++ return {+ twModalDialog: cachedTwModalDialog,+ setCodeEditor: needsCodeEditor ? cachedSetCodeEditor : null,+ };+}++/**+ * Creates an expand button element with proper styling and accessibility+ * Uses passive event listeners for hover effect to avoid blocking the main thread+ */+function createExpandButton(): HTMLButtonElement {+ const expandButton = document.createElement('button');+ expandButton.type = 'button';+ expandButton.classList.add('expand-textarea-btn');+ expandButton.setAttribute('aria-label', 'Expand textarea');+ expandButton.classList.add(+ 'absolute',+ 'bottom-2',+ 'right-2',+ 'text-gray-500',+ 'hover:text-gray-700',+ 'opacity-50',+ 'hover:opacity-100',+ 'transition-opacity',+ 'cursor-pointer',+ );++ // Add expand icon SVG+ expandButton.innerHTML = `+ <svg stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 24 24" class="fa-md" height="1em" width="1em" xmlns="http://www.w3.org/2000/svg"><path d="M5 12H3v9h9v-2H5zm7-7h7v7h2V3h-9z"></path></svg>+ `;++ // Add hover effect using passive event listeners for better performance+ expandButton.addEventListener(+ 'pointerenter',+ () => {+ expandButton.style.opacity = '1';+ },+ { passive: true },+ );++ expandButton.addEventListener(+ 'pointerleave',+ () => {+ expandButton.style.opacity = '0.5';+ },+ { passive: true },+ );++ return expandButton;+}++/**+ * Handles key/value modal for the modal textarea+ * @param {HTMLTextAreaElement} modalTextarea - The modal textarea to update+ * @param {HTMLButtonElement} originalButton - The original button to extract parameters from+ */+async function handleKeyValueModalForModal(+ modalTextarea: HTMLTextAreaElement,+ originalButton: HTMLButtonElement,+): Promise<void> {+ try {+ // Extract field name from the original textarea+ const originalTextarea = originalButton+ .closest('.form-group')+ ?.querySelector('textarea') as HTMLTextAreaElement;+ const fieldName = originalTextarea?.id || 'body';++ // Extract options from the original button's onclick handler+ const originalHandler = (originalButton as any).onclick;+ let options = { title: 'Body', showVault: true, vaultScope: 'apiCall' }; // Default options++ // Try to extract options from the bound function+ if (originalHandler && originalHandler.length > 1) {+ // This is a bound function, try to extract the bound arguments+ const handlerString = originalHandler.toString();+ if (handlerString.includes('showVault')) {+ // Extract options from the handler string or use defaults+ options = { title: 'Body', showVault: true, vaultScope: 'apiCall' };+ }+ }++ // Call the key/value modal handler directly+ await handleKvFieldEditBtn(fieldName, options);++ // The handler should have updated the element with the fieldName ID+ // But we need to copy that value to our modal textarea+ const updatedField = document.getElementById(fieldName) as HTMLTextAreaElement;+ if (updatedField && updatedField.value !== modalTextarea.value) {+ modalTextarea.value = updatedField.value;++ // Dispatch events to trigger any listeners+ const changeEvent = new Event('change', { bubbles: true });+ modalTextarea.dispatchEvent(changeEvent);++ const inputEvent = new Event('input', { bubbles: true });+ modalTextarea.dispatchEvent(inputEvent);+ }+ } catch (error) {+ console.error('Error handling key/value modal for modal textarea:', error);+ }+}++/**+ * Creates a vault key button element with proper styling and accessibility+ * Positioned at the top right of the textarea+ */+function createVaultButton(): HTMLButtonElement {+ const vaultButton = document.createElement('button');+ vaultButton.type = 'button';+ vaultButton.classList.add('vault-action-btn', 'field-action-btn');+ vaultButton.setAttribute('aria-label', 'Vault keys');+ vaultButton.setAttribute('data-smyth-dropdown-toggle', 'vault-keys-dropdown-menu');+ vaultButton.classList.add(+ 'absolute',+ 'top-2',+ 'right-2', // Position at top right+ 'text-gray-500',+ 'hover:text-gray-700',+ 'opacity-50',+ 'hover:opacity-100',+ 'transition-opacity',+ 'cursor-pointer',+ 'z-10', // Ensure it's above other elements+ );++ // Add vault key icon+ vaultButton.innerHTML = `<i class="mif-key fa-md"></i>`;++ // Add hover effect using passive event listeners for better performance+ vaultButton.addEventListener(+ 'pointerenter',+ () => {+ vaultButton.style.opacity = '1';+ },+ { passive: true },+ );++ vaultButton.addEventListener(+ 'pointerleave',+ () => {+ vaultButton.style.opacity = '0.5';+ },+ { passive: true },+ );++ // Don't add click handler here - it will be added in the onLoad callback+ // This prevents duplicate event handlers++ return vaultButton;+}++/**+ * Get the current code configuration for a textarea based on its attributes and data+ * This ensures the expandable textarea uses the current content type configuration+ */+function getCurrentCodeConfig(+ textarea: HTMLTextAreaElement,+ fallbackCode?: CodeConfig,+ attributes?: Record<string, string>,+): CodeConfig | undefined {+ // Priority 1: Check textarea data attributes (highest priority)+ const textareaCodeConfig = getCodeConfigFromAttributes(textarea);+ if (textareaCodeConfig) {+ return textareaCodeConfig;+ }++ // Priority 2: Check if textarea has existing editor instance+ if ((textarea as TextAreaWithEditor)._editor) {+ return fallbackCode || getDefaultCodeConfig();+ }++ // Priority 3: Check content type (APICall components only)+ const contentTypeConfig = getCodeConfigFromContentType(textarea);+ if (contentTypeConfig) {+ return contentTypeConfig;+ }++ // Priority 4: Check attributes parameter+ if (attributes) {+ const attributesCodeConfig = getCodeConfigFromAttributes(undefined, attributes);+ if (attributesCodeConfig) {+ return attributesCodeConfig;+ }+ }++ // Priority 5: Fallback to entry-provided configuration+ return fallbackCode;+}++/**+ * Extract code configuration from element attributes or attributes object+ */+function getCodeConfigFromAttributes(+ element?: HTMLTextAreaElement,+ attributes?: Record<string, string>,+): CodeConfig | undefined {+ const source = element || attributes;+ if (!source) return undefined;++ const getAttr = (name: string) => {+ if (element) {+ return element.getAttribute(name);+ }+ return attributes?.[name];+ };++ const mode = getAttr('data-code-mode');+ const theme = getAttr('data-code-theme');+ const disableWorker = getAttr('data-code-disable-worker');++ if (mode || theme || disableWorker) {+ return {+ mode: mode || undefined,+ theme: theme || undefined,+ disableWorker: disableWorker === 'true' || undefined,+ };+ }++ return undefined;+}++/**+ * Get code configuration based on content type (APICall components)+ */+function getCodeConfigFromContentType(textarea: HTMLTextAreaElement): CodeConfig | undefined {+ const contentType = textarea.getAttribute('data-content-type');++ if (!contentType) return undefined;++ const contentTypeModes: Record<string, string> = {+ 'application/json': 'json',+ 'application/javascript': 'javascript',+ 'text/html': 'html',+ };++ const mode = contentTypeModes[contentType];+ if (mode) {+ return {+ mode,+ theme: 'tomorrow',+ disableWorker: false,+ };+ }++ return undefined;+}++/**+ * Get default code configuration+ */+function getDefaultCodeConfig(): { mode: string; theme: string; disableWorker: boolean } {+ return {+ mode: 'text',+ theme: 'tomorrow',+ disableWorker: false,+ };+}++/**+ * Apply all attributes and configurations to a textarea element+ */+function applyTextareaConfiguration(+ textarea: HTMLTextAreaElement,+ config: {+ attributes?: Record<string, string>;+ code?: CodeConfig;+ },+): void {+ const { attributes, code } = config;++ // Apply all attributes to the textarea+ if (attributes) {+ Object.entries(attributes).forEach(([key, value]) => {+ textarea.setAttribute(key, value);+ });+ }++ // Store code configuration as data attributes for dynamic access+ if (code) {+ if (code.mode) textarea.setAttribute('data-code-mode', code.mode);+ if (code.theme) textarea.setAttribute('data-code-theme', code.theme);+ if (code.disableWorker !== undefined) {+ textarea.setAttribute('data-code-disable-worker', code.disableWorker.toString());+ }+ }++ // Store component UID in textarea data attribute for template variables+ const currentComponent = (window as any).Component?.curComponentSettings || null;+ const compUid =+ currentComponent?._uid || document.querySelector('.component.active')?.getAttribute('id') || '';+ if (compUid) {+ textarea.setAttribute('data-component-uid', compUid);+ }+}++/**+ * Apply styles to a textarea element based on whether it's a code editor or regular textarea+ */+function applyTextareaStyles(textarea: HTMLTextAreaElement, isCodeEditor: boolean): void {+ if (isCodeEditor) {+ // Minimal styles for code editor - the editor handles most styling+ textarea.style.cssText = `+ width: 100%;+ min-height: 400px;+ border: 1px solid #d1d5db;+ border-radius: 6px;+ font-size: 14px;+ outline: none;+ `;+ }+}++/**+ * Synchronize values between modal textarea and original textarea+ * Handles both regular textareas and code editor instances+ */+function syncTextareaValues(+ modalTextarea: TextAreaWithEditor,+ originalTextarea: TextAreaWithEditor,+ hasCodeEditor: boolean,+): void {+ let valueToSync = modalTextarea.value;++ // If it's a code editor, get value from the editor instance+ if (hasCodeEditor && modalTextarea._editor) {+ valueToSync = modalTextarea._editor.getValue();+ }++ // Update the original textarea+ originalTextarea.value = valueToSync;++ // If original textarea has an editor, update it too+ if (originalTextarea._editor) {+ originalTextarea._editor.setValue(valueToSync);+ }++ // Trigger input event to notify any listeners+ const changeEvent = new Event('input', { bubbles: true });+ originalTextarea.dispatchEvent(changeEvent);+}++/**+ * Initialize code editor in a textarea element+ * Uses requestAnimationFrame for optimal DOM readiness detection+ * Adds json-editor class to match inline textarea behavior+ * Sets up Ace editor with bracket selection for variable syntax+ */+async function initializeCodeEditor(+ textarea: TextAreaWithEditor,+ setCodeEditor: typeof import('../../dom').setCodeEditor,+ mode: string,+ theme: string,+ disableWorker: boolean | undefined,+ initialValue: string,+): Promise<void> {+ // Wait for DOM to be ready using requestAnimationFrame instead of setTimeout+ await new Promise((resolve) => requestAnimationFrame(resolve));++ // Initialize the code editor+ setCodeEditor(textarea, mode, theme, disableWorker);++ // Add json-editor class to match inline textarea behavior+ textarea.classList.add('json-editor');++ // Wait for editor initialization and set value+ await new Promise((resolve) => requestAnimationFrame(resolve));++ if (textarea._editor) {+ textarea._editor.setValue(initialValue);+ textarea._editor.focus();++ // For modal context, configure the ace editor to handle scrolling properly+ // The ace editor is configured with maxLines: Infinity which makes it grow to show all content+ // We need to enable the ace editor's internal scrolling for long content in modals+ if (textarea._editor.container && textarea._editor.setOption && textarea._editor.resize) {+ const editorContainer = textarea._editor.container;+ // Override maxLines to enable internal scrolling instead of infinite growth+ textarea._editor.setOption('maxLines', null);+ // Set a reasonable height that fits within the modal+ editorContainer.style.height = '100%';+ editorContainer.style.minHeight = '200px';+ // Ensure the ace editor's scrollbars are visible+ textarea._editor.setOption('vScrollBarAlwaysVisible', false);+ textarea._editor.setOption('hScrollBarAlwaysVisible', false);+ // Remove the sidebar class to allow scrollbars in modals+ editorContainer.classList.remove('ace-editor-sidebar');+ // Trigger resize to apply new dimensions+ textarea._editor.resize(true);+ }++ // Setup bracket selection for Ace editor content+ const aceContentElement = textarea._editor.container?.querySelector(+ '.ace_content',+ ) as HTMLElement | null;+ if (aceContentElement) {+ addBracketSelection(aceContentElement);+ }+ }+}++/**+ * Initialize a regular textarea by focusing and positioning cursor at the end+ */+function initializeRegularTextarea(textarea: HTMLTextAreaElement): void {+ // Use requestAnimationFrame for optimal timing instead of setTimeout+ requestAnimationFrame(() => {+ textarea.focus();+ // Set cursor at the end+ textarea.setSelectionRange(textarea.value.length, textarea.value.length);+ });+}++/**+ * Copy all relevant attributes from source textarea to target textarea+ * This ensures the modal textarea has the same behavior and appearance as the original+ */+function copyTextareaAttributes(+ sourceTextarea: HTMLTextAreaElement,+ targetTextarea: HTMLTextAreaElement,+ additionalAttributes?: Record<string, string>,+): void {+ // Define all relevant attributes that should be copied+ const relevantAttributes = [+ // Form control attributes+ 'readonly',+ 'disabled',+ 'placeholder',+ // Template variables attributes+ 'data-template-vars',+ 'data-agent-vars',+ 'data-template-excluded-vars',+ 'data-template-excluded-var-types',+ ];++ // Copy all relevant attributes from source to target+ relevantAttributes.forEach((attr) => {+ const value = sourceTextarea.getAttribute(attr);+ if (value !== null) {+ targetTextarea.setAttribute(attr, value);+ }+ });++ // Apply additional attributes from the attributes parameter+ if (additionalAttributes) {+ Object.entries(additionalAttributes).forEach(([key, value]) => {+ targetTextarea.setAttribute(key, value);+ });+ }+}++/**+ * Initialize template variables UI inside the modal if enabled on the textarea+ */+function setupTemplateVarsIfNeeded(+ dialogElm: HTMLElement,+ modalTextareaInDialog: TextAreaWithEditor,+ currentComponent: { _uid: string } | null,+): void {+ const hasTemplateVars = modalTextareaInDialog.getAttribute('data-template-vars') === 'true';+ const hasAgentVars = modalTextareaInDialog.getAttribute('data-agent-vars') === 'true';++ if (!hasTemplateVars && !hasAgentVars) {+ return;+ }++ // Clean up any existing template variable wrappers in the modal first+ const existingWrappers = dialogElm.querySelectorAll('.template-var-buttons');+ existingWrappers.forEach((wrapper) => wrapper.remove());++ // Find the form group within the modal and set up template vars on that specific container+ const modalFormGroup = modalTextareaInDialog.closest('.form-group') as HTMLElement | null;+ if (modalFormGroup) {+ handleTemplateVars(modalFormGroup, currentComponent as any);+ }+}++/**+ * Attach vault button behavior for the modal textarea (with toggle and editor support)+ */+function setupVaultInDialog(+ dialogElm: HTMLElement,+ modalTextareaInDialog: TextAreaWithEditor,+ vaultCondition?: { property: string; value: string; getValue?: () => string },+ contentType?: string,+): void {+ // The vault button should already be in the modal from the HTML content+ // We need to re-attach the click handler since the button was recreated from HTML+ const vaultButton = dialogElm.querySelector('.vault-action-btn') as HTMLButtonElement | null;+ if (!vaultButton) {+ return;+ }++ // Remove existing click handlers by cloning the element+ vaultButton.replaceWith(vaultButton.cloneNode(true));+ const newVaultButton = dialogElm.querySelector('.vault-action-btn') as HTMLButtonElement | null;+ if (!newVaultButton) {+ return;+ }++ newVaultButton.addEventListener('click', async (event) => {+ event.preventDefault();+ event.stopPropagation();++ // Toggle dropdown+ const existingDropdown = document.getElementById('vault-keys-dropdown-menu');+ if (existingDropdown) {+ existingDropdown.remove();+ return;+ }++ const formGroup = newVaultButton.closest('.form-group');+ const targetField = formGroup?.querySelector('[data-vault]') as TextAreaWithEditor | null;++ // Open vault dropdown using existing handler+ await handleVaultBtn(event as MouseEvent);++ // Enhance dropdown behavior for code editor inputs+ setTimeout(() => {+ const vaultDropdown = document.getElementById('vault-keys-dropdown-menu');+ if (!vaultDropdown) return;++ const keyButtons = vaultDropdown.querySelectorAll('a[data-value]');+ keyButtons.forEach((keyBtn) => {+ const originalOnclick = (keyBtn as unknown as { onclick?: (e: Event) => void }).onclick;+ if (!originalOnclick) return;++ (keyBtn as HTMLElement).onclick = (ev: Event) => {+ ev.preventDefault();++ if ((targetField as TextAreaWithEditor | null)?._editor) {+ const editor = (targetField as TextAreaWithEditor)._editor;+ if (!editor) return;+ const keyVar = `{{KEY(${keyBtn.textContent})}}`;+ // Insert into editor at current selection+ // @ts-expect-error: session/selection are provided by the editor implementation+ editor.session.replace(editor.selection.getRange(), keyVar);+ // @ts-expect-error: editor API+ editor.moveCursorToPosition(editor.getCursorPosition());+ editor.focus();++ const inputEvent = new Event('input', { bubbles: true });+ (targetField as HTMLTextAreaElement).dispatchEvent(inputEvent);+ } else {+ // Fallback to original handler for regular textareas+ originalOnclick(ev);+ }++ const dropdown = document.getElementById('vault-keys-dropdown-menu');+ if (dropdown) dropdown.remove();++ if (targetField) {+ (targetField as HTMLTextAreaElement).focus();+ (targetField as HTMLTextAreaElement).scrollTop = (+ targetField as HTMLTextAreaElement+ ).scrollHeight;++ const inputEvent = new Event('input', { bubbles: true });+ (targetField as HTMLTextAreaElement).dispatchEvent(inputEvent);+ const changeEvent = new Event('change', { bubbles: true });+ (targetField as HTMLTextAreaElement).dispatchEvent(changeEvent);+ }+ };+ });+ }, 500);++ // After vault handler runs, ensure focus/update+ setTimeout(() => {+ const updatedTargetField = newVaultButton+ .closest('.form-group')+ ?.querySelector('[data-vault]') as HTMLTextAreaElement | null;+ if (updatedTargetField) {+ updatedTargetField.focus();+ updatedTargetField.scrollTop = updatedTargetField.scrollHeight;+ const inputEvent = new Event('input', { bubbles: true });+ updatedTargetField.dispatchEvent(inputEvent);+ }+ }, 1000);+ });++ // Show/hide vault button based on condition (or show by default if data-vault exists)+ let shouldShowVault = true;+ if (vaultCondition) {+ shouldShowVault = shouldShowVaultButton(vaultCondition, contentType);+ }+ newVaultButton.style.display = shouldShowVault ? 'inline-block' : 'none';+}++/**+ * Re-attach action buttons from the original form group to the modal+ */+function reattachActionButtons(+ dialogElm: HTMLElement,+ originalTextarea: TextAreaWithEditor,+ modalTextareaInDialog: TextAreaWithEditor,+): void {+ const originalFormGroup = originalTextarea.closest('.form-group');+ if (!originalFormGroup) return;++ const actionButtons = originalFormGroup.querySelectorAll(+ '.smyth-field-actions button, .button-group button',+ ) as NodeListOf<HTMLButtonElement>;++ actionButtons.forEach((originalButton, index) => {+ if (originalButton.classList.contains('vault-action-btn')) return;++ const modalActionButton = dialogElm.querySelector(+ `button[data-action-index="${index}"]`,+ ) as HTMLButtonElement | null;+ if (!modalActionButton) return;++ const originalClickHandler = (originalButton as unknown as { onclick?: (e: Event) => void })+ .onclick;+ if (originalClickHandler) {+ modalActionButton.onclick = async (event) => {+ const buttonId = originalButton.id;+ const buttonIcon = originalButton.querySelector('i')?.className;++ if (buttonIcon?.includes('pen-to-square') || buttonId?.includes('EditBtn')) {+ await handleKeyValueModalForModal(modalTextareaInDialog, originalButton);+ return;+ }++ const originalId = originalTextarea.id;+ const originalName = originalTextarea.name;++ modalTextareaInDialog.id = originalId;+ modalTextareaInDialog.name = originalName;++ await originalClickHandler.call(originalButton, event);++ originalTextarea.id = originalId;+ originalTextarea.name = originalName;+ };+ }++ const originalEvents =+ (originalButton as unknown as { _events?: Record<string, EventListener> })._events || {};+ Object.keys(originalEvents).forEach((eventType) => {+ modalActionButton.addEventListener(eventType, originalEvents[eventType] as EventListener);+ });+ });+}++/**+ * Handles the expansion of a textarea into a modal dialog+ * Creates modal content, handles code editor initialization, and manages value synchronization+ */+async function handleExpandTextarea(+ originalTextarea: TextAreaWithEditor,+ label: string | undefined,+ code: CodeConfig | undefined,+ attributes: Record<string, string> | undefined,+ contentType?: string,+ vaultCondition?: { property: string; value: string; getValue?: () => string },+ validateMessage?: string,+): Promise<void> {+ // Dynamically determine code configuration from textarea attributes+ // This ensures the expandable textarea uses the current content type configuration+ // For APICall components, or falls back to the entry-provided configuration for other components+ const currentCodeConfig = getCurrentCodeConfig(originalTextarea, code, attributes);++ // Load required modules+ const { twModalDialog, setCodeEditor } = await getModalImports(!!currentCodeConfig);+ const hasCodeEditor = !!currentCodeConfig;++ // Get component UID for template variables - try multiple approaches++ // First, try to get it from the original textarea's data attribute (if it was stored)+ const compUid = originalTextarea.getAttribute('data-component-uid');++ // Create a mock component object with the UID for handleTemplateVars+ const currentComponent = compUid ? { _uid: compUid } : null;++ // Create modal content container+ const modalContainer = document.createElement('div');+ modalContainer.classList.add('h-full', 'flex', 'flex-col', 'form-group');++ // Create textarea wrapper for positioning buttons - this needs to be a form-group for vault button to work+ const textareaWrapper = document.createElement('div');+ textareaWrapper.classList.add('relative', 'form-group');+ textareaWrapper.style.position = 'relative';+ textareaWrapper.style.flex = '1';+ textareaWrapper.style.display = 'flex';+ textareaWrapper.style.flexDirection = 'column';+ // Use 'auto' to enable scrolling when ace editor content exceeds modal height+ // The ace editor is configured with maxLines: Infinity and height: 'auto', which means it grows to fit all content+ textareaWrapper.style.overflow = 'auto';++ // Create modal textarea+ const modalTextarea = document.createElement('textarea') as TextAreaWithEditor;+ modalTextarea.value = originalTextarea.value;+ modalTextarea.classList.add('form-control', 'flex-1', 'resize-none', 'overflow-y-auto');+ modalTextarea.id = 'expanded-textarea';++ // Copy validation attributes from original textarea for Metro UI validation+ const validateAttr = originalTextarea.getAttribute('data-validate');+ if (validateAttr) {+ modalTextarea.setAttribute('data-validate', validateAttr);+ }++ // Apply styles based on editor type+ applyTextareaStyles(modalTextarea, hasCodeEditor);++ // Add vault button to modal textarea if original textarea has vault attributes+ const hasVaultAttribute = originalTextarea.getAttribute('data-vault');++ if (hasVaultAttribute) {+ // Copy vault attribute to modal textarea+ modalTextarea.setAttribute('data-vault', hasVaultAttribute);++ // Mark this textarea as coming from expanded/modal view+ // This is used to hide the "Add Key" option in the vault dropdown+ modalTextarea.setAttribute('data-vault-from-modal', 'true');++ // Create vault button for modal+ const modalVaultButton = createVaultButton();+ textareaWrapper.appendChild(modalVaultButton);+ }++ // Add other action buttons from the original textarea+ const originalFormGroup = originalTextarea.closest('.form-group');+ if (originalFormGroup) {+ // Find all action buttons in the original form group+ const actionButtons = originalFormGroup.querySelectorAll(+ '.smyth-field-actions button, .button-group button',+ );++ actionButtons.forEach((button, index) => {+ // Skip vault button as we handle it separately+ if (button.classList.contains('vault-action-btn')) return;++ // Clone the button for the modal+ const modalActionButton = button.cloneNode(true) as HTMLButtonElement;++ // Add data attribute for later identification+ modalActionButton.setAttribute('data-action-index', index.toString());++ // Adjust positioning for modal context - stack buttons vertically+ modalActionButton.style.position = 'absolute';+ modalActionButton.style.top = `${2 + index * 32}px`; // Stack buttons with 32px spacing+ modalActionButton.style.right = '2px';+ modalActionButton.style.zIndex = '10';++ // Re-attach event listeners by finding the original button's click handler+ const originalClickHandler = (button as any).onclick;+ if (originalClickHandler) {+ modalActionButton.onclick = originalClickHandler;+ }++ // Also try to find and re-attach other event listeners+ const originalEvents = (button as any)._events || {};+ Object.keys(originalEvents).forEach((eventType) => {+ modalActionButton.addEventListener(eventType, originalEvents[eventType]);+ });++ textareaWrapper.appendChild(modalActionButton);+ });+ }++ // Create validation message element if provided+ let validationMessageElm: HTMLElement | null = null;+ if (validateMessage) {+ validationMessageElm = document.createElement('div');+ validationMessageElm.classList.add('mt-2', 'invalid_feedback');+ validationMessageElm.textContent = validateMessage;+ }++ // Create template variable buttons container+ const templateVarsContainer = document.createElement('div');+ templateVarsContainer.classList.add('template-var-buttons', 'mt-2');+ templateVarsContainer.style.display = 'none';++ textareaWrapper.appendChild(modalTextarea);+ if (validationMessageElm) {+ textareaWrapper.appendChild(validationMessageElm);+ }+ modalContainer.appendChild(textareaWrapper);+ modalContainer.appendChild(templateVarsContainer);++ // Open modal dialog (content must be HTML string, not element)+ await twModalDialog({+ title: label || 'Edit',+ content: modalContainer.outerHTML,+ size: {+ width: '80vw',+ height: '80vh',+ maxWidth: '1200px',+ maxHeight: '800px',+ },+ actions: [],+ onLoad: async (dialogElm: HTMLElement) => {+ const modalTextareaInDialog = dialogElm.querySelector('textarea') as TextAreaWithEditor;++ if (!modalTextareaInDialog) {+ return;+ }++ // Set initial value+ modalTextareaInDialog.value = originalTextarea.value;++ // Copy all relevant attributes from the original textarea to the modal textarea+ copyTextareaAttributes(originalTextarea, modalTextareaInDialog, attributes);++ // Initialize based on editor type+ if (hasCodeEditor && currentCodeConfig && setCodeEditor) {+ const mode = currentCodeConfig.mode || '';+ const theme = currentCodeConfig.theme || 'tomorrow';+ const disableWorker = currentCodeConfig.disableWorker;++ await initializeCodeEditor(+ modalTextareaInDialog,+ setCodeEditor,+ mode,+ theme,+ disableWorker,+ originalTextarea.value,+ );+ } else {+ initializeRegularTextarea(modalTextareaInDialog);++ // Setup bracket selection for modal textarea+ addBracketSelection(modalTextareaInDialog);+ }++ // Template variables setup (if enabled)+ setupTemplateVarsIfNeeded(dialogElm, modalTextareaInDialog, currentComponent);++ // Set up vault functionality if the textarea has vault attributes+ const hasVaultAttribute = modalTextareaInDialog.getAttribute('data-vault');++ if (hasVaultAttribute) {+ setupVaultInDialog(dialogElm, modalTextareaInDialog, vaultCondition, contentType);+ }++ // Re-attach other action buttons+ reattachActionButtons(dialogElm, originalTextarea, modalTextareaInDialog);++ // Simple validation: check maxlength and add .invalid class if exceeded+ const validateAttr = originalTextarea.getAttribute('data-validate');+ const maxLengthMatch = validateAttr?.match(/maxlength=(\d+)/);++ if (maxLengthMatch) {+ const maxLength = parseInt(maxLengthMatch[1], 10);+ const validateError = dialogElm.querySelector('.invalid_feedback') as HTMLElement;++ /**+ * Real-time validation on input+ */+ const checkValidation = (): void => {+ const formGroup = modalTextareaInDialog.closest('.form-group') as HTMLElement;+ if (modalTextareaInDialog?.value?.trim()?.length > maxLength) {+ formGroup?.classList.add('invalid');+ modalTextareaInDialog.classList.add('invalid');+ if (validateError) validateError.style.display = 'block';+ } else {+ formGroup?.classList.remove('invalid');+ modalTextareaInDialog.classList.remove('invalid');+ if (validateError) validateError.style.display = 'none';+ }+ };++ modalTextareaInDialog.addEventListener('input', checkValidation);+ checkValidation(); // Check on load+ }+ },+ onCloseClick(dialogElm: HTMLElement) {+ const modalTextareaInDialog = dialogElm.querySelector('textarea') as TextAreaWithEditor;++ const existingDropdown = document.getElementById('vault-keys-dropdown-menu');+ if (existingDropdown) {+ // Dropdown is open, close it (toggle off)+ existingDropdown.remove();+ }++ if (modalTextareaInDialog) {+ syncTextareaValues(modalTextareaInDialog, originalTextarea, hasCodeEditor);+ }++ // Clean up any template variable wrappers within the modal+ const templateVarWrappers = dialogElm.querySelectorAll('.template-var-buttons');+ templateVarWrappers.forEach((wrapper) => wrapper.remove());+ },+ });+}++/**+ * Creates a textarea element with optional expand functionality and dynamic vault button+ * @param entry - Configuration object for the textarea+ * @param entry.value - Initial value for the textarea+ * @param entry.fieldCls - Additional CSS classes for the textarea+ * @param entry.autoSize - Whether to enable auto-size functionality+ * @param entry.expandable - Whether to show an expand button for modal editing+ * @param entry.label - Label for the modal title+ * @param entry.attributes - Additional attributes for the textarea+ * @param entry.code - Code editor configuration (mode, theme, disableWorker)+ * @param entry.contentType - Content type for backward compatibility+ * @param entry.validateMessage - Validation error message to display in the modal+ * @param entry.vaultCondition - Dynamic condition for showing vault button+ * @param entry.vaultCondition.property - Property name to check (e.g., 'contentType', 'mode', 'type')+ * @param entry.vaultCondition.value - Value that should trigger vault button display+ * @param entry.vaultCondition.getValue - Optional function to get current value dynamically+ * @returns Object containing the textarea element and optional container wrapper+ *+ */+export const createTextArea = (entry: {+ label?: string;+ value?: string;+ fieldCls?: string;+ autoSize?: boolean;+ expandable?: boolean;+ attributes?: Record<string, string>;+ code?: {+ mode?: string;+ theme?: string;+ disableWorker?: boolean;+ };+ contentType?: string;+ validateMessage?: string;+ vaultCondition?: {+ property: string;+ value: string;+ getValue?: () => string;+ };+}): HTMLTextAreaElement | { textarea: HTMLTextAreaElement; container: HTMLDivElement } => {+ const {+ value = '',+ fieldCls = '',+ autoSize = true,+ expandable,+ label,+ attributes,+ code,+ contentType,+ validateMessage,+ vaultCondition,+ } = entry;+ const textarea = document.createElement('textarea');+ textarea.setAttribute('data-role', 'textarea');+ textarea.innerHTML = value;+ textarea.classList.add('form-control');++ if (fieldCls) {+ textarea.setAttribute('data-cls-textarea', fieldCls);+ }++ textarea.setAttribute('data-auto-size', `${autoSize}`);++ // Apply all attributes and configurations to the textarea+ applyTextareaConfiguration(textarea, { attributes, code });++ // If expandable is true, wrap textarea with container and add expand button+ if (expandable) {+ const container = document.createElement('div');+ container.classList.add('relative');+ container.style.position = 'relative';++ // Create expand button with CSS-based hover effects+ const expandButton = createExpandButton();++ // Add click handler to open modal (async handler with error handling)+ expandButton.addEventListener('click', async (e) => {+ e.preventDefault();+ e.stopPropagation();++ try {+ // Get current code configuration dynamically from textarea attributes+ const currentCodeConfig = getCurrentCodeConfig(textarea, code, attributes);+ await handleExpandTextarea(+ textarea,+ label,+ currentCodeConfig,+ attributes,+ contentType,+ vaultCondition,+ validateMessage,+ );+ } catch (error) {+ console.error('Error opening textarea modal:', error);+ }+ });++ container.appendChild(textarea);+ container.appendChild(expandButton);++ return { textarea, container };+ }++ return textarea;+};++export const createButton = (label: string, value: string): HTMLButtonElement => {+ const button = document.createElement('button');+ button.classList.add('button');+ button.innerHTML = label || value;++ return button;+};++export const createColorInput = (value: string): HTMLInputElement => {+ const colorInput = createInput(value);++ colorInput.setAttribute('data-clear-button', 'false');+ colorInput.setAttribute('type', 'text');+ colorInput.classList.add('coloris');++ return colorInput;+};++export function createInfoButton(+ text,+ {+ cls = '',+ clsHint = '',+ position,+ tooltipClasses = '',+ arrowClasses = '',+ }: {+ cls?: string;+ clsHint?: string;+ position?: string;+ tooltipClasses?: string;+ arrowClasses?: string;+ },+ entryIndex = 0,+) {+ // Calculate width based on text length, but allow more space for tooltips with links+ const hasLinks = text.includes('<a ');+ let estimatedWidth = text.length * 2 > 48 ? 48 : text.length * 2;++ // If tooltip contains links, use a more generous width calculation+ if (hasLinks) {+ estimatedWidth = Math.min(60, Math.max(40, text.length * 1.8));+ }+ // TODO: This is a temporary fix to avoid the tooltip being cutoff in the sidebar and showing it on the top.+ // if (entryIndex < 2) {+ // position = position || 'bottom';+ // }++ // Enforce consistent tooltip placement above to avoid cutoff in the sidebar+ position = 'top';++ // Create a container for the React component+ const tooltipContainer = document.createElement('div');+ tooltipContainer.className = 'inline-block align-middle ' + cls;++ // Create the info icon as a React element+ const iconElement = React.createElement('img', {+ className: 'opacity-80 hover:opacity-100',+ style: {+ width: '16px',+ height: '16px',+ },+ src: '/img/icons/Info.svg',+ });++ // Sanitize the HTML content to prevent XSS attacks+ // DOMPurify's default configuration already allows all safe HTML tags+ // and blocks dangerous elements like <script>, event handlers, etc.+ const sanitizedText = DOMPurify.sanitize(text);++ // Render the Tooltip component wrapped in TooltipProvider+ const root = createRoot(tooltipContainer);+ root.render(+ React.createElement(+ TooltipProvider,+ { delayDuration: 300, skipDelayDuration: 100 },+ React.createElement(+ Tooltip,+ {},+ React.createElement(TooltipTrigger, { asChild: true }, iconElement),+ React.createElement(+ TooltipContent,+ {+ side: position as any,+ className:+ clsHint ++ ' whitespace-normal text-xs ' ++ (tooltipClasses || (hasLinks ? `min-w-52 max-w-96` : `w-${estimatedWidth}`)) ++ ' [&_a]:whitespace-nowrap [&_a]:inline-block',+ },+ React.createElement('div', {+ dangerouslySetInnerHTML: { __html: sanitizedText },+ }),+ ),+ ),+ ),+ );++ // Add cleanup when the button is removed+ const observer = new MutationObserver((mutations) => {+ mutations.forEach((mutation) => {+ if (mutation.type === 'childList' && mutation.removedNodes.length > 0) {+ mutation.removedNodes.forEach((node) => {+ // Check if the removed node is our specific info button+ if (node === tooltipContainer || node.contains(tooltipContainer)) {+ root.unmount();+ observer.disconnect();+ }+ });+ }+ });+ });++ // Find the sidebar container and start observing+ const sidebarContainer = document.getElementById('sidebar-container');+ if (sidebarContainer) {+ observer.observe(sidebarContainer, {+ childList: true,+ subtree: true, // Enable subtree observation to catch nested removals+ });+ }++ return tooltipContainer;+}++type RangeEntry = {+ name: string;+ min: number;+ max: number;+ value: number;+ step?: number;+};+export function createRangeInput({ name, min, max, value, step }: RangeEntry) {+ // create range input+ const range = document.createElement('input');+ range.type = 'range';++ /* Set step if provided+ We must set the step before setting the value to keep fraction part */+ if (step) {+ range.step = `${step}`;+ }++ range.min = `${min}`;+ range.max = `${max}`;+ range.value = `${value}`; // value must be set after min, mix and step+ range.className = 'form-control w-[75%] h-2 cursor-pointer mx-2 my-3.5 rounded';++ // create number input+ const input = document.createElement('input');+ input.setAttribute('data-role', 'input');+ input.setAttribute('data-clear-button', 'false');+ input.type = 'number';++ /* Set step if provided+ We must set the step before setting the value to keep fraction part */+ if (step) {+ input.step = `${step}`;+ }++ input.min = `${min}`;+ input.max = `${max}`;+ input.value = `${value}`; // value must be set after min, mix and step+ input.setAttribute('data-rel', `#${name}`);+ input.className = 'form-control w-[30%] ml-1 rounded';++ // sync the number input with range+ range.addEventListener('input', (event) => {+ const elm = event.target as HTMLInputElement;++ input.value = elm.value;+ });++ // sync the range with number input+ input.addEventListener('keydown', async (event) => {+ const elm = event.target as HTMLInputElement;++ // Need to a slight delay get the updated value+ await delay(50);++ range.value = elm.value;+ });++ // sync the range with number input+ input.addEventListener('wheel', async (event) => {+ const elm = event.target as HTMLInputElement;++ // Need to a slight delay get the updated value+ await delay(50);++ range.value = elm.value;+ });++ return { rangeInput: range, numberInput: input };+}+/**+ * Creates a toggle switch input element with associated label+ * @param label - The label text for the toggle+ * @param value - The initial checked state of the toggle+ * @param hintOnSelect - Optional hint text to show when toggle is checked+ * @returns HTMLDivElement - The configured toggle input element with hint+ */+export function createToggle(label: string, value: boolean | string, hintOnSelect?: string) {+ const toggle = document.createElement('input');+ toggle.type = 'checkbox';++ if (value) toggle.setAttribute('checked', '');+ else toggle.removeAttribute('checked');++ toggle.className = [+ 'relative w-[35px] h-[20px] items-center',+ 'bg-[#757575] border-transparent text-transparent rounded-3xl',+ 'cursor-pointer transition-colors ease-in-out duration-200',+ 'disabled:opacity-50 disabled:pointer-events-none',+ 'checked:bg-none checked:text-blue-600 checked:border-blue-600 checked:bg-blue-600',+ 'focus:ring-0 focus:ring-offset-0 focus:ring-offset-transparent',+ 'before:inline-block before:w-4 before:h-4 before:bg-white',+ 'before:rounded-full before:shadow before:transform before:ring-0',+ 'before:transition before:ease-in-out before:duration-200 before:mt-[1px]',+ 'before:ml-[1px] before:translate-x-px checked:before:translate-x-full',+ 'checked:before:bg-blue-200 checked:before:ml-0',+ ].join(' ');++ return toggle;+}++export function createTagInput({ maxTags, value }: { maxTags: number; value: string }) {+ const input = document.createElement('input');+ input.setAttribute('data-role', 'taginput');+ input.setAttribute('data-max-tags', `${maxTags}`);+ input.value = value;++ return input;+}++/**+ * Creates a hint element with sanitized HTML content+ * @param text - The HTML text content to display in the hint+ * @returns HTMLElement - The hint element with sanitized content+ */+export function createHint(text: string) {+ const elm = document.createElement('small');+ elm.classList.add('field-hint');++ // Sanitize the HTML content to prevent XSS attacks+ // DOMPurify's default configuration already allows all safe HTML tags+ // and blocks dangerous elements like <script>, event handlers, etc.+ const sanitizedText = DOMPurify.sanitize(text);++ elm.innerHTML = sanitizedText;++ return elm;+}++type RadioOption = {+ value: string;+ text: string;+ icon?: string;+ captionPosition?: 'left' | 'right';+ classes?: {+ radio?: string;+ caption?: string;+ check?: string;+ };+};+/**+ * Creates a group of radio buttons with Metro UI styling and optional custom icons+ * @param options - Array of radio options with value and text+ * @param value - Currently selected value+ * @param name - Group name to link radio buttons together+ * @returns HTMLDivElement containing the radio buttons+ */+export function createRadio({+ options,+ name,+ value,+ events,+ fieldCls = '',+ readonly = false,+}: {+ options: Array<RadioOption>;+ name: string;+ value: string;+ events: Record<string, Function>;+ fieldCls?: string;+ readonly?: boolean;+}) {+ const container = document.createElement('div');+ container.className = 'radio-container form-control';++ options.forEach((option) => {+ const radio = document.createElement('input');+ radio.setAttribute('data-role', 'radio');+ radio.name = name;+ radio.value = option.value;+ radio.checked = option?.value === value || false;+ if (readonly) radio.disabled = readonly;+ radio.setAttribute('data-caption', option.text);++ if (option.captionPosition) {+ radio.setAttribute('data-caption-position', option.captionPosition);+ }++ // Apply classes with icon-specific modifications+ const classConfigs = {+ 'data-cls-radio': (option.classes?.radio || '') + ' ' + fieldCls,+ 'data-cls-caption': option.classes?.caption || '',+ 'data-cls-check': option.classes?.check || '',+ };++ // Set class attributes if they exist+ for (const [attr, classes] of Object.entries(classConfigs)) {+ if (classes) {+ radio.setAttribute(attr, `${classes}`.trim());+ }+ }++ // Only append if no icon (fixing the logic error in original code)+ container.appendChild(radio);++ // Add events to the radio button+ for (const [type, listener] of Object.entries(events)) {+ radio.addEventListener(type, listener as EventListener);+ }+ });++ return container;+}diff --git a/packages/app/src/builder-ui/ui/form/fields/multiSelectBox.field.ts b/packages/app/src/builder-ui/ui/form/fields/multiSelectBox.field.tsnew file mode 100644index 00000000..ec616f31--- /dev/null+++ b/packages/app/src/builder-ui/ui/form/fields/multiSelectBox.field.ts@@ -0,0 +1,345 @@+/**+ * Creates a simple, user-friendly multi-select with checkboxes and visual chips+ * This uses native HTML5 elements without Metro UI+ * Features:+ * - Search input to filter options+ * - Checkboxes for easy selection (simple click, no Ctrl/Cmd needed)+ * - Visual chips showing selected items+ * - Hidden select element for form compatibility+ * @param options - Array of option objects with text and value properties+ * @param value - Array of selected values+ * @param dropdownHeight - Optional height for the options list in pixels+ * @returns HTMLDivElement containing the complete multi-select UI+ */+export const createMultiSelectBox = (+ options: Array<{ value: string; text: string }> | any,+ value: string[],+ dropdownHeight?: number,+): HTMLDivElement => {+ /**+ * Main container - position relative for absolute positioning of dropdown+ */+ const container = document.createElement('div');+ container.classList.add('multi-select-container');+ container.style.cssText = 'display: flex; flex-direction: column; gap: 8px; position: relative;';++ /**+ * Selected items display area (chips/tags) with caret+ */+ const selectedChipsWrapper = document.createElement('div');+ selectedChipsWrapper.style.cssText = 'position: relative; display: flex; align-items: center;';++ const selectedChips = document.createElement('div');+ selectedChips.classList.add('multi-select-chips');+ selectedChips.style.cssText =+ 'display: flex; flex-wrap: wrap; gap: 6px; min-height: 36px; padding: 6px 32px 6px 6px; border: 1px solid #d1d5db; border-radius: 6px; background: #f9fafb; flex: 1; cursor: pointer; transition: background-color 0.15s ease;';+ selectedChips.innerHTML =+ '<span style="color: #9ca3af; font-size: 14px;">No items selected</span>';++ /**+ * Add hover effect to chips area+ */+ selectedChips.addEventListener('mouseenter', () => {+ selectedChips.style.backgroundColor = '#f3f4f6';+ });+ selectedChips.addEventListener('mouseleave', () => {+ selectedChips.style.backgroundColor = '#f9fafb';+ });++ /**+ * Caret/dropdown icon (inside selected chips area)+ */+ const caretIcon = document.createElement('span');+ caretIcon.classList.add('multi-select-caret');+ caretIcon.innerHTML = '▼';+ caretIcon.style.cssText =+ 'position: absolute; right: 10px; font-size: 12px; color: #6b7280; pointer-events: none; transition: transform 0.2s ease;';++ /**+ * Dropdown wrapper - contains search input and options list+ * Positioned absolutely to float over other content+ */+ const dropdownWrapper = document.createElement('div');+ dropdownWrapper.classList.add('multi-select-dropdown');+ dropdownWrapper.style.cssText =+ 'position: absolute; top: 100%; left: 0; right: 0; z-index: 1000; margin-top: 4px; display: none; flex-direction: column; gap: 8px; background: white; border: 1px solid #d1d5db; border-radius: 6px; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06); padding: 8px;';++ /**+ * Search input for filtering options+ */+ const searchInput = document.createElement('input');+ searchInput.type = 'text';+ searchInput.placeholder = 'Search options...';+ searchInput.classList.add('multi-select-search', 'form-control');+ searchInput.style.cssText =+ 'padding: 8px; border-radius: 6px; border: 1px solid #d1d5db; width: 100%;';++ /**+ * Options list container with checkboxes+ */+ const optionsList = document.createElement('div');+ optionsList.classList.add('multi-select-options');+ const height = dropdownHeight || 200;+ optionsList.style.cssText = `max-height: ${height}px; overflow-y: auto; border-radius: 6px; background: white;`;++ /**+ * Hidden select element for form compatibility+ * This stores the actual selected values for form submission+ */+ const hiddenSelect = document.createElement('select');+ hiddenSelect.setAttribute('multiple', 'multiple');+ hiddenSelect.style.display = 'none';+ hiddenSelect.classList.add('multi-select-native');++ /**+ * Store all options and selected values+ */+ let allOptions: Array<{ value: string; text: string }> = [];+ const selectedValues = new Set<string>(Array.isArray(value) ? value : []);++ /**+ * Create a chip element for a selected item+ */+ const createChip = (optionValue: string, optionText: string): HTMLElement => {+ const chip = document.createElement('span');+ chip.style.cssText =+ 'display: inline-flex; align-items: center; gap: 4px; padding: 4px 8px; background: #3b82f6; color: white; border-radius: 4px; font-size: 14px;';+ chip.innerHTML = `+ ${optionText}+ <button type="button" style="background: none; border: none; color: white; cursor: pointer; font-size: 16px; line-height: 1; padding: 0; margin-left: 4px;" data-value="${optionValue}">×</button>+ `;++ // Remove chip on click+ const removeBtn = chip.querySelector('button') as HTMLButtonElement;+ removeBtn.addEventListener('click', (e) => {+ e.preventDefault();+ e.stopPropagation();+ const val = removeBtn.getAttribute('data-value');+ if (val) {+ selectedValues.delete(val);+ updateUI();+ // Trigger change event+ hiddenSelect.dispatchEvent(new Event('change', { bubbles: true }));+ }+ });++ return chip;+ };++ /**+ * Update the UI based on selected values+ */+ const updateUI = (): void => {+ // Update chips display+ selectedChips.innerHTML = '';+ if (selectedValues.size === 0) {+ selectedChips.innerHTML =+ '<span style="color: #9ca3af; font-size: 14px;">No items selected</span>';+ } else {+ selectedValues.forEach((val) => {+ const option = allOptions.find((opt) => opt.value === val);+ if (option) {+ selectedChips.appendChild(createChip(option.value, option.text));+ }+ });+ }++ // Update hidden select+ hiddenSelect.innerHTML = '';+ selectedValues.forEach((val) => {+ const option = document.createElement('option');+ option.value = val;+ option.selected = true;+ hiddenSelect.appendChild(option);+ });++ // Update checkmark icons in the options list+ const optionItems = optionsList.querySelectorAll('[data-value]');+ optionItems.forEach((item) => {+ const value = item.getAttribute('data-value');+ const checkmark = item.querySelector('.checkmark-icon') as HTMLElement;+ if (checkmark && value) {+ checkmark.style.display = selectedValues.has(value) ? 'inline-block' : 'none';+ }+ });+ };++ /**+ * Create option element with checkmark icon+ */+ const createOptionElement = (option: { value: string; text: string }): HTMLElement => {+ const isSelected = selectedValues.has(option.value);++ const label = document.createElement('div');+ label.style.cssText =+ 'display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; cursor: pointer; user-select: none; border-bottom: 1px solid #f3f4f6;';+ label.setAttribute('data-value', option.value);++ label.innerHTML = `+ <span style="font-size: 14px;">${option.text}</span>+ <span class="checkmark-icon" style="font-size: 18px; color: #10b981; font-weight: bold; display: ${isSelected ? 'inline-block' : 'none'};">✓</span>+ `;++ // Handle click to toggle selection+ label.addEventListener('click', () => {+ const value = label.getAttribute('data-value');+ if (!value) return;++ const checkmark = label.querySelector('.checkmark-icon') as HTMLElement;++ if (selectedValues.has(value)) {+ selectedValues.delete(value);+ checkmark.style.display = 'none';+ } else {+ selectedValues.add(value);+ checkmark.style.display = 'inline-block';+ }++ updateUI();+ // Trigger change event on hidden select+ hiddenSelect.dispatchEvent(new Event('change', { bubbles: true }));+ });++ // Hover effect+ label.addEventListener('mouseenter', () => {+ label.style.background = '#f3f4f6';+ });+ label.addEventListener('mouseleave', () => {+ label.style.background = 'white';+ });++ return label;+ };++ /**+ * Populate options list with optional filtering+ */+ const populateOptions = (filterText: string = ''): void => {+ optionsList.innerHTML = '';++ const filtered = filterText+ ? allOptions.filter(+ (option) =>+ option.text.toLowerCase().includes(filterText.toLowerCase()) ||+ option.value.toLowerCase().includes(filterText.toLowerCase()),+ )+ : allOptions;++ if (filtered.length === 0) {+ optionsList.innerHTML =+ '<div style="padding: 12px; text-align: center; color: #9ca3af;">No options found</div>';+ } else {+ filtered.forEach((option) => {+ optionsList.appendChild(createOptionElement(option));+ });+ }+ };++ /**+ * Toggle dropdown visibility+ */+ let isOpen = false;+ const toggleDropdown = (): void => {+ isOpen = !isOpen;+ dropdownWrapper.style.display = isOpen ? 'flex' : 'none';+ caretIcon.style.transform = isOpen ? 'rotate(180deg)' : 'rotate(0deg)';++ // Focus search input when opening+ if (isOpen) {+ setTimeout(() => searchInput.focus(), 100);+ } else {+ searchInput.value = '';+ populateOptions('');+ }+ };++ /**+ * Set up selected chips click handler to toggle dropdown+ */+ selectedChips.addEventListener('click', (e) => {+ // Don't toggle if clicking on remove button+ const target = e.target as HTMLElement;+ if (target.tagName === 'BUTTON' || target.closest('button')) {+ return;+ }+ e.stopPropagation();+ toggleDropdown();+ });++ /**+ * Set up search input for filtering+ */+ searchInput.addEventListener('input', (e) => {+ const target = e.target as HTMLInputElement;+ populateOptions(target.value);+ });++ /**+ * Prevent closing when clicking on search input+ */+ searchInput.addEventListener('click', (e) => {+ e.stopPropagation();+ });++ /**+ * Close dropdown when clicking outside+ */+ document.addEventListener('click', (e) => {+ if (!container.contains(e.target as Node) && isOpen) {+ toggleDropdown();+ }+ });++ /**+ * Handle async or sync options+ */+ if (typeof options === 'function') {+ setTimeout(() => {+ const formBox = container.closest('.form-box');+ if (formBox) formBox.classList.add('loading');+ }, 300);++ options().then((data: Array<{ value: string; text: string }>) => {+ allOptions = data;+ populateOptions();+ updateUI();++ const formBox = container.closest('.form-box');+ if (formBox) {+ setTimeout(() => {+ formBox.classList.remove('loading');+ }, 300);+ }+ });+ } else {+ allOptions = options;+ populateOptions();+ updateUI();+ }++ /**+ * Assemble the selected chips wrapper+ */+ selectedChipsWrapper.appendChild(selectedChips);+ selectedChipsWrapper.appendChild(caretIcon);++ /**+ * Assemble the dropdown wrapper (floating)+ */+ dropdownWrapper.appendChild(searchInput);+ dropdownWrapper.appendChild(optionsList);++ /**+ * Assemble the container+ */+ container.appendChild(selectedChipsWrapper);+ container.appendChild(dropdownWrapper);+ container.appendChild(hiddenSelect);++ /**+ * Store reference to the hidden select element for form handling+ */+ (container as any)._selectElement = hiddenSelect;++ return container;+};