aura-glass 2.0.39 → 2.1.0

package/dist/esm/components/input/GlassLabel.js

@@ -0,0 +1,75 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { forwardRef } from 'react';
+import { cn } from '../../lib/utilsComprehensive.js';
+import { useA11yId } from '../../utils/a11y.js';
+
+const GlassLabel = /*#__PURE__*/forwardRef(({
+  size = "md",
+  variant = "default",
+  required = false,
+  disabled = false,
+  icon,
+  description,
+  enhanced = false,
+  className,
+  children,
+  id,
+  'data-testid': dataTestId,
+  ...props
+}, ref) => {
+  const labelId = useA11yId("glass-label");
+  const finalId = id || labelId;
+  const sizeConfig = {
+    xs: "glass-text-xs",
+    sm: "glass-text-sm",
+    md: "glass-text-sm",
+    lg: "glass-text-base"
+  };
+  const variantConfig = {
+    default: "text-foreground",
+    muted: "glass-text-secondary",
+    accent: "text-primary",
+    success: "text-green-400",
+    warning: "text-amber-400",
+    error: "text-red-400"
+  };
+  return jsxs("div", {
+    "data-glass-component": true,
+    className: "glass-label-container",
+    children: [jsxs("label", {
+      ref: ref,
+      id: finalId,
+      "data-testid": dataTestId ?? 'glasslabel',
+      className: cn("glass-label", "font-medium leading-none transition-colors duration-200", "peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+      // Size
+      sizeConfig[size],
+      // Variant
+      variantConfig[variant],
+      // Disabled state
+      disabled && "opacity-50 cursor-not-allowed",
+      // Icon spacing
+      icon && "flex items-center glass-gap-2",
+      // Enhanced styling
+      enhanced && "glass-focus", className),
+      ...props,
+      children: [icon && jsx("span", {
+        className: 'shrink-0',
+        children: icon
+      }), jsxs("span", {
+        children: [children, required && jsx("span", {
+          className: 'text-destructive glass-ml-1',
+          "aria-label": "required",
+          children: "*"
+        })]
+      })]
+    }), description && jsx("p", {
+      className: cn("glass-label-description glass-text-secondary glass-mt-1", size === "xs" ? "glass-text-xs" : "glass-text-sm", disabled && "opacity-50"),
+      children: description
+    })]
+  });
+});
+GlassLabel.displayName = "GlassLabel";
+
+export { GlassLabel, GlassLabel as default };
+//# sourceMappingURL=GlassLabel.js.map

package/dist/esm/components/input/GlassLabel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlassLabel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/components/input/GlassMultiSelect.js

@@ -0,0 +1,520 @@
+'use client';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import React, { forwardRef, useId, useRef, useState, useMemo, useCallback, useEffect } from 'react';
+import { cn } from '../../lib/utilsComprehensive.js';
+import { ClearIcon } from '../icons/ClearIcon.js';
+import styles from './GlassMultiSelect.module.css.js';
+
+const defaultFilter = (option, input) => {
+  return option.label.toLowerCase().includes(input.toLowerCase());
+};
+const valueKey = option => {
+  if (option.id !== undefined) return String(option.id);
+  return String(option.value);
+};
+const normalizeValue = value => {
+  if (value === undefined || value === null) return '';
+  return String(value);
+};
+const mergeOptionCollections = (options, groups, withGroups) => {
+  if (withGroups && groups && groups.length > 0) {
+    return groups.flatMap(group => group.options ?? []);
+  }
+  return options ?? [];
+};
+const buildOptionLookup = options => {
+  const map = new Map();
+  options.forEach(option => {
+    map.set(valueKey(option), option);
+  });
+  return map;
+};
+function ensureOption(optionLookup, value) {
+  const existing = optionLookup.get(String(value));
+  if (existing) return existing;
+  return {
+    value,
+    label: String(value)
+  };
+}
+function flattenGroups(groups, fallbackOptions, withGroups) {
+  if (withGroups && groups && groups.length > 0) {
+    return groups.map(group => ({
+      group,
+      options: group.options ?? []
+    }));
+  }
+  return [{
+    options: fallbackOptions
+  }];
+}
+const createCreatableOption = inputValue => ({
+  id: `__creatable__${inputValue}`,
+  value: inputValue,
+  label: inputValue,
+  __isCreatable__: true
+});
+const GlassMultiSelectInternal = (props, ref) => {
+  const {
+    options = [],
+    groups,
+    withGroups,
+    value,
+    defaultValue,
+    onChange,
+    placeholder = 'Select…',
+    label,
+    helperText,
+    error,
+    errorMessage,
+    fullWidth,
+    width,
+    size = 'medium',
+    disabled,
+    searchable = true,
+    clearable = true,
+    creatable,
+    closeOnSelect = true,
+    clearInputOnSelect = true,
+    keyboardNavigation = true,
+    filterOptions,
+    filterFunction,
+    onCreateOption,
+    onInputChange,
+    onRemove,
+    onSelect,
+    onOpen,
+    onClose,
+    loading,
+    loadingText = 'Loading…',
+    noOptionsText = 'No options',
+    renderOption,
+    renderToken,
+    renderValue,
+    renderGroup,
+    maxSelections,
+    maxHeight = 280,
+    openUp,
+    ariaLabel,
+    autoFocus,
+    dataTestId,
+    id,
+    className,
+    style
+  } = props;
+  const generatedId = useId();
+  const inputId = id ?? `glass-multi-select-${generatedId}`;
+  const rootRef = useRef(null);
+  const inputRef = useRef(null);
+  const dropdownRef = useRef(null);
+  const [isOpen, setIsOpen] = useState(false);
+  const [inputValue, setInputValue] = useState('');
+  const [focusedIndex, setFocusedIndex] = useState(-1);
+  const [openDirectionUp, setOpenDirectionUp] = useState(undefined);
+  const allOptions = useMemo(() => mergeOptionCollections(options, groups, withGroups), [options, groups, withGroups]);
+  const optionLookup = useMemo(() => buildOptionLookup(allOptions), [allOptions]);
+  const initializeValue = useCallback(values => {
+    if (!values || values.length === 0) return [];
+    return values.map(val => ensureOption(optionLookup, val));
+  }, [optionLookup]);
+  const isControlled = value !== undefined;
+  const [internalSelected, setInternalSelected] = useState(() => initializeValue(isControlled ? value : defaultValue));
+  const selectedOptions = isControlled ? initializeValue(value) : internalSelected;
+  const notifyChange = useCallback(next => {
+    const valuesOnly = next.map(opt => opt.value);
+    onChange?.(valuesOnly);
+  }, [onChange]);
+  const updateSelected = useCallback(next => {
+    if (!isControlled) {
+      setInternalSelected(next);
+    }
+    notifyChange(next);
+  }, [isControlled, notifyChange]);
+  useEffect(() => {
+    if (isControlled) {
+      setInternalSelected(initializeValue(value));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isControlled, value, optionLookup]);
+  useEffect(() => {
+    if (!isOpen) return;
+    if (openUp !== undefined) {
+      setOpenDirectionUp(openUp);
+      return;
+    }
+    const container = rootRef.current;
+    if (!container) return;
+    const rect = container.getBoundingClientRect();
+    const viewportHeight = window.innerHeight;
+    const availableBelow = viewportHeight - rect.bottom;
+    const availableAbove = rect.top;
+    const shouldOpenUp = availableBelow < 200 && availableAbove > availableBelow;
+    setOpenDirectionUp(shouldOpenUp);
+  }, [isOpen, openUp]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleOutsideClick = event => {
+      const container = rootRef.current;
+      if (!container) return;
+      if (!container.contains(event.target)) {
+        setIsOpen(false);
+        onClose?.();
+      }
+    };
+    document.addEventListener('mousedown', handleOutsideClick);
+    return () => {
+      document.removeEventListener('mousedown', handleOutsideClick);
+    };
+  }, [isOpen, onClose]);
+  useEffect(() => {
+    if (autoFocus) {
+      inputRef.current?.focus();
+    }
+  }, [autoFocus]);
+  const groupedOptions = useMemo(() => flattenGroups(groups, options, withGroups), [groups, options, withGroups]);
+  const filteredGroups = useMemo(() => {
+    if (!searchable || !inputValue.trim()) {
+      return groupedOptions;
+    }
+    const userFilter = opts => {
+      if (filterOptions) {
+        try {
+          return filterOptions(opts, inputValue);
+        } catch (error) {
+          return opts;
+        }
+      }
+      if (filterFunction) {
+        try {
+          const result = filterFunction(opts, inputValue);
+          if (Array.isArray(result)) {
+            return result;
+          }
+          // Allow predicate-style fallthrough
+        } catch (error) {
+          // Fallthrough to default filter
+        }
+      }
+      return opts.filter(option => defaultFilter(option, inputValue));
+    };
+    const filteredFlat = userFilter(allOptions);
+    const allowedKeys = new Set(filteredFlat.map(option => valueKey(option)));
+    return groupedOptions.map(group => ({
+      group: group.group,
+      options: group.options.filter(option => allowedKeys.has(valueKey(option)))
+    })).filter(group => group.options.length > 0);
+  }, [searchable, inputValue, groupedOptions, filterOptions, filterFunction, allOptions]);
+  const flatOptionList = useMemo(() => {
+    const flattened = [];
+    filteredGroups.forEach(({
+      options: groupOptions
+    }) => {
+      flattened.push(...groupOptions);
+    });
+    if (creatable && inputValue.trim()) {
+      const existing = flattened.find(option => normalizeValue(option.value) === normalizeValue(inputValue));
+      if (!existing) {
+        flattened.push(createCreatableOption(inputValue.trim()));
+      }
+    }
+    return flattened;
+  }, [filteredGroups, creatable, inputValue]);
+  useEffect(() => {
+    if (!isOpen) {
+      setFocusedIndex(-1);
+      return;
+    }
+    if (keyboardNavigation) {
+      setFocusedIndex(flatOptionList.length > 0 ? 0 : -1);
+    }
+  }, [isOpen, flatOptionList, keyboardNavigation]);
+  const handleOpen = useCallback(() => {
+    if (disabled) return;
+    if (!isOpen) {
+      setIsOpen(true);
+      onOpen?.();
+    }
+  }, [disabled, isOpen, onOpen]);
+  const handleClose = useCallback(() => {
+    if (isOpen) {
+      setIsOpen(false);
+      onClose?.();
+    }
+  }, [isOpen, onClose]);
+  const handleSelectOption = useCallback(option => {
+    if (option.disabled) return;
+    if (option.__isCreatable__) {
+      onCreateOption?.(option.label);
+    }
+    const alreadySelected = selectedOptions.some(selected => normalizeValue(selected.value) === normalizeValue(option.value));
+    let nextSelected;
+    if (alreadySelected) {
+      nextSelected = selectedOptions.filter(selected => normalizeValue(selected.value) !== normalizeValue(option.value));
+      onRemove?.(option.value);
+    } else {
+      if (maxSelections && selectedOptions.length >= maxSelections) {
+        return;
+      }
+      nextSelected = [...selectedOptions, option];
+      onSelect?.(option);
+    }
+    updateSelected(nextSelected);
+    if (clearInputOnSelect) {
+      setInputValue('');
+      onInputChange?.('');
+    }
+    if (closeOnSelect) {
+      handleClose();
+    }
+  }, [selectedOptions, updateSelected, clearInputOnSelect, closeOnSelect, handleClose, onInputChange, onSelect, onCreateOption, maxSelections]);
+  const handleRemoveOption = useCallback(option => {
+    const next = selectedOptions.filter(selected => normalizeValue(selected.value) !== normalizeValue(option.value));
+    updateSelected(next);
+    onRemove?.(option.value);
+  }, [selectedOptions, onRemove, updateSelected]);
+  const handleClearAll = useCallback(() => {
+    selectedOptions.forEach(option => {
+      onRemove?.(option.value);
+    });
+    updateSelected([]);
+    setInputValue('');
+    onInputChange?.('');
+  }, [selectedOptions, onRemove, onInputChange, updateSelected]);
+  const handleInputChange = useCallback(event => {
+    const nextValue = event.target.value;
+    setInputValue(nextValue);
+    onInputChange?.(nextValue);
+    if (!isOpen) {
+      setIsOpen(true);
+      onOpen?.();
+    }
+  }, [isOpen, onInputChange, onOpen]);
+  const focusPrevious = useCallback(() => {
+    setFocusedIndex(prev => {
+      if (!keyboardNavigation) return prev;
+      if (flatOptionList.length === 0) return -1;
+      const nextIndex = prev <= 0 ? flatOptionList.length - 1 : prev - 1;
+      return nextIndex;
+    });
+  }, [flatOptionList.length, keyboardNavigation]);
+  const focusNext = useCallback(() => {
+    setFocusedIndex(prev => {
+      if (!keyboardNavigation) return prev;
+      if (flatOptionList.length === 0) return -1;
+      const nextIndex = prev >= flatOptionList.length - 1 ? 0 : prev + 1;
+      return nextIndex;
+    });
+  }, [flatOptionList.length, keyboardNavigation]);
+  const handleKeyDown = useCallback(event => {
+    if (disabled) return;
+    switch (event.key) {
+      case 'ArrowDown':
+        event.preventDefault();
+        handleOpen();
+        focusNext();
+        break;
+      case 'ArrowUp':
+        event.preventDefault();
+        handleOpen();
+        focusPrevious();
+        break;
+      case 'Enter':
+        if (isOpen && focusedIndex >= 0 && focusedIndex < flatOptionList.length) {
+          event.preventDefault();
+          handleSelectOption(flatOptionList[focusedIndex]);
+        }
+        break;
+      case 'Escape':
+        if (isOpen) {
+          event.preventDefault();
+          handleClose();
+        }
+        break;
+      case 'Backspace':
+        if (inputValue === '' && selectedOptions.length > 0) {
+          event.preventDefault();
+          const lastOption = selectedOptions[selectedOptions.length - 1];
+          handleRemoveOption(lastOption);
+        }
+        break;
+    }
+  }, [disabled, handleOpen, focusNext, focusPrevious, isOpen, focusedIndex, flatOptionList, handleSelectOption, handleClose, inputValue, selectedOptions, handleRemoveOption]);
+  const handleContainerClick = useCallback(() => {
+    if (disabled) return;
+    handleOpen();
+    inputRef.current?.focus();
+  }, [disabled, handleOpen]);
+  const dropdownMaxHeight = typeof maxHeight === 'number' ? `${maxHeight}px` : maxHeight;
+  const renderTokens = () => {
+    if (renderValue) {
+      return renderValue(selectedOptions);
+    }
+    return selectedOptions.map(option => {
+      if (renderToken) {
+        return jsx("div", {
+          className: cn('galileo-multiselect-token-wrapper'),
+          children: renderToken(option, () => handleRemoveOption(option))
+        }, valueKey(option));
+      }
+      return jsxs("span", {
+        className: cn(styles.token, 'galileo-multiselect-token', option.disabled && styles.tokenDisabled),
+        children: [jsx("span", {
+          className: styles.tokenLabel,
+          children: option.label
+        }), !disabled && !option.disabled && jsx("button", {
+          type: "button",
+          className: cn(styles.removeButton, 'remove-button'),
+          onClick: event => {
+            event.stopPropagation();
+            handleRemoveOption(option);
+          },
+          "aria-label": `Remove ${option.label}`,
+          children: jsx(ClearIcon, {})
+        })]
+      }, valueKey(option));
+    });
+  };
+  const dropdownClassName = cn(styles.dropdown, isOpen && styles.dropdownVisible, openDirectionUp && styles.dropdownAbove);
+  const containerClassName = cn(styles.container, styles[`size${size.charAt(0).toUpperCase()}${size.slice(1)}`], error && styles.containerError, disabled && styles.containerDisabled, !disabled && isOpen && styles.containerFocused);
+  const rootClassName = cn(styles.root, fullWidth && styles.rootFullWidth, className);
+  const resolvedWidthValue = fullWidth ? '100%' : width ? typeof width === 'number' ? `${width}px` : width : undefined;
+  const inlineStyle = {
+    ...(style ?? {})
+  };
+  if (resolvedWidthValue) {
+    inlineStyle['--multi-select-width'] = resolvedWidthValue;
+  }
+  inlineStyle['--multi-select-dropdown-height'] = dropdownMaxHeight;
+  return jsxs("div", {
+    ref: mergeRefs(ref, rootRef),
+    className: rootClassName,
+    style: inlineStyle,
+    "data-testid": dataTestId,
+    children: [label && jsx("label", {
+      className: styles.label,
+      htmlFor: inputId,
+      children: label
+    }), jsxs("div", {
+      className: containerClassName,
+      onClick: handleContainerClick,
+      role: "combobox",
+      "aria-expanded": isOpen,
+      "aria-haspopup": "listbox",
+      "aria-disabled": disabled,
+      "aria-controls": `${inputId}-listbox`,
+      children: [jsxs("div", {
+        className: styles.tokenList,
+        children: [selectedOptions.length > 0 ? renderTokens() : !inputValue && jsx("span", {
+          className: styles.placeholder,
+          children: placeholder
+        }), jsx("input", {
+          ref: inputRef,
+          id: inputId,
+          className: styles.input,
+          type: "text",
+          value: inputValue,
+          onChange: handleInputChange,
+          onFocus: handleOpen,
+          onKeyDown: handleKeyDown,
+          placeholder: selectedOptions.length === 0 ? placeholder : '',
+          disabled: disabled || !searchable,
+          "aria-autocomplete": "list",
+          "aria-controls": `${inputId}-listbox`,
+          "aria-expanded": isOpen,
+          "aria-label": ariaLabel || label || placeholder,
+          autoComplete: "off"
+        })]
+      }), clearable && selectedOptions.length > 0 && !disabled && jsx("button", {
+        type: "button",
+        className: styles.clearButton,
+        onClick: event => {
+          event.stopPropagation();
+          handleClearAll();
+        },
+        "aria-label": "Clear all selections",
+        children: jsx(ClearIcon, {})
+      })]
+    }), helperText && !error && jsx("div", {
+      className: styles.helperText,
+      children: helperText
+    }), error && errorMessage && jsx("div", {
+      className: styles.errorText,
+      children: errorMessage
+    }), jsxs("div", {
+      ref: dropdownRef,
+      className: dropdownClassName,
+      role: "presentation",
+      children: [loading && jsxs("div", {
+        className: styles.loading,
+        children: [jsx("span", {
+          className: styles.spinner,
+          "aria-hidden": "true"
+        }), jsx("span", {
+          children: loadingText
+        })]
+      }), !loading && flatOptionList.length === 0 && jsx("div", {
+        className: styles.noOptions,
+        children: noOptionsText
+      }), !loading && flatOptionList.length > 0 && jsxs("ul", {
+        className: styles.optionList,
+        role: "listbox",
+        id: `${inputId}-listbox`,
+        children: [filteredGroups.map(({
+          group,
+          options: groupOptions
+        }) => jsxs(React.Fragment, {
+          children: [group?.label && (renderGroup ? renderGroup(group) : jsx("li", {
+            className: styles.groupHeader,
+            children: group.label
+          })), groupOptions.map(option => {
+            const key = valueKey(option);
+            const isSelected = selectedOptions.some(selected => normalizeValue(selected.value) === normalizeValue(option.value));
+            const optionIndex = flatOptionList.findIndex(item => normalizeValue(item.value) === normalizeValue(option.value));
+            const isFocused = optionIndex === focusedIndex;
+            const optionClassName = cn(styles.option, isSelected && styles.optionSelected, isFocused && styles.optionFocused, option.disabled && styles.optionDisabled);
+            return jsx("li", {
+              role: "option",
+              "aria-selected": isSelected,
+              className: optionClassName,
+              onClick: event => {
+                event.preventDefault();
+                handleSelectOption(option);
+              },
+              onMouseEnter: () => setFocusedIndex(optionIndex),
+              children: renderOption ? renderOption(option, isSelected) : option.label
+            }, key);
+          })]
+        }, group?.id ?? group?.label ?? 'group-default')), flatOptionList.length > 0 && creatable && inputValue.trim() && (() => {
+          const creatableOption = flatOptionList.find(opt => opt.__isCreatable__);
+          if (!creatableOption) return null;
+          const optionIndex = flatOptionList.findIndex(item => item.__isCreatable__);
+          const optionClassName = cn(styles.option, optionIndex === focusedIndex && styles.optionFocused);
+          return jsxs("li", {
+            className: optionClassName,
+            onClick: event => {
+              event.preventDefault();
+              handleSelectOption(creatableOption);
+            },
+            onMouseEnter: () => setFocusedIndex(optionIndex),
+            children: ["Create \u201C", inputValue.trim(), "\u201D"]
+          }, creatableOption.id);
+        })()]
+      })]
+    })]
+  });
+};
+function mergeRefs(forwardedRef, localRef) {
+  return value => {
+    localRef.current = value;
+    if (typeof forwardedRef === 'function') {
+      forwardedRef(value);
+    } else if (forwardedRef) {
+      forwardedRef.current = value;
+    }
+  };
+}
+const GlassMultiSelect = /*#__PURE__*/forwardRef(GlassMultiSelectInternal);
+GlassMultiSelect.displayName = 'GlassMultiSelect';
+
+export { GlassMultiSelect, GlassMultiSelect as default };
+//# sourceMappingURL=GlassMultiSelect.js.map

package/dist/esm/components/input/GlassMultiSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlassMultiSelect.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/components/input/GlassMultiSelect.module.css.js

@@ -0,0 +1,4 @@
+var styles = {"root":"GlassMultiSelect-module_root__vHkT0","rootFullWidth":"GlassMultiSelect-module_rootFullWidth__imBVt","label":"GlassMultiSelect-module_label__uzmmC","container":"GlassMultiSelect-module_container__mwN2M","containerFocused":"GlassMultiSelect-module_containerFocused__MZWgP","containerError":"GlassMultiSelect-module_containerError__w2uUk","containerDisabled":"GlassMultiSelect-module_containerDisabled__xHKBP","sizeSmall":"GlassMultiSelect-module_sizeSmall__hjFkl","sizeMedium":"GlassMultiSelect-module_sizeMedium__KAMqR","sizeLarge":"GlassMultiSelect-module_sizeLarge__cNvWL","tokenList":"GlassMultiSelect-module_tokenList__tfJcN","placeholder":"GlassMultiSelect-module_placeholder__8fx6L","token":"GlassMultiSelect-module_token__zbzcv","tokenDisabled":"GlassMultiSelect-module_tokenDisabled__-T7iO","tokenLabel":"GlassMultiSelect-module_tokenLabel__Cbcqg","removeButton":"GlassMultiSelect-module_removeButton__HQkzm","input":"GlassMultiSelect-module_input__t8WV-","clearButton":"GlassMultiSelect-module_clearButton__K1bL7","dropdown":"GlassMultiSelect-module_dropdown__7rdFm","dropdownVisible":"GlassMultiSelect-module_dropdownVisible__tbclp","dropdownAbove":"GlassMultiSelect-module_dropdownAbove__-gISD","optionList":"GlassMultiSelect-module_optionList__wlOjx","option":"GlassMultiSelect-module_option__XGKaY","optionSelected":"GlassMultiSelect-module_optionSelected__Paln6","optionFocused":"GlassMultiSelect-module_optionFocused__Xz2n4","optionDisabled":"GlassMultiSelect-module_optionDisabled__voldE","groupHeader":"GlassMultiSelect-module_groupHeader__gxFGF","helperText":"GlassMultiSelect-module_helperText__IAMuA","errorText":"GlassMultiSelect-module_errorText__3XzYz","noOptions":"GlassMultiSelect-module_noOptions__20hHV","loading":"GlassMultiSelect-module_loading__nPBSx","spinner":"GlassMultiSelect-module_spinner__94F8H","spin":"GlassMultiSelect-module_spin__yNDWd"};
+
+export { styles as default };
+//# sourceMappingURL=GlassMultiSelect.module.css.js.map

package/dist/esm/components/input/GlassMultiSelect.module.css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlassMultiSelect.module.css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}