@esri/calcite-components 1.0.0-next.290 → 1.0.0-next.294

package/dist/components/interfaces2.js

@@ -0,0 +1,14 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+var TreeSelectionMode;
+(function (TreeSelectionMode) {
+  TreeSelectionMode["Single"] = "single";
+  TreeSelectionMode["Multi"] = "multi";
+  TreeSelectionMode["Children"] = "children";
+  TreeSelectionMode["MultiChildren"] = "multi-children";
+  TreeSelectionMode["Ancestors"] = "ancestors";
+})(TreeSelectionMode || (TreeSelectionMode = {}));
+
+export { TreeSelectionMode as T };

package/dist/components/key.js

@@ -0,0 +1,33 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+/**
+ * Standardize key property of keyboard event (mostly for ie11)
+ */
+function getKey(key, dir) {
+  const lookup = {
+    Up: "ArrowUp",
+    Down: "ArrowDown",
+    Left: "ArrowLeft",
+    Right: "ArrowRight",
+    Spacebar: " ",
+    Esc: "Escape"
+  };
+  const adjustedKey = lookup[key] || key;
+  const isRTL = dir === "rtl";
+  if (isRTL && adjustedKey === "ArrowLeft") {
+    return "ArrowRight";
+  }
+  if (isRTL && adjustedKey === "ArrowRight") {
+    return "ArrowLeft";
+  }
+  return adjustedKey;
+}
+function isActivationKey(key) {
+  key = getKey(key);
+  return key === "Enter" || key === " ";
+}
+const numberKeys = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+
+export { getKey as g, isActivationKey as i, numberKeys as n };

package/dist/components/label.js

@@ -0,0 +1,54 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+import { q as queryElementRoots, d as closestElementCrossShadowBoundary } from './dom.js';
+
+const labelTagName = "calcite-label";
+const labelClickEvent = "calciteInternalLabelClick";
+const onLabelClickMap = new WeakMap();
+const findLabelForComponent = (componentEl) => {
+  const id = componentEl.id;
+  return ((id && queryElementRoots(componentEl, `${labelTagName}[for="${id}"]`)) ||
+    closestElementCrossShadowBoundary(componentEl, labelTagName));
+};
+/**
+ * Helper to set up label interactions on connectedCallback.
+ */
+function connectLabel(component) {
+  const labelEl = findLabelForComponent(component.el);
+  if (!labelEl || onLabelClickMap.has(labelEl)) {
+    return;
+  }
+  component.labelEl = labelEl;
+  const boundOnLabelClick = onLabelClick.bind(component);
+  onLabelClickMap.set(component.labelEl, boundOnLabelClick);
+  component.labelEl.addEventListener(labelClickEvent, boundOnLabelClick);
+}
+/**
+ * Helper to tear down label interactions on disconnectedCallback.
+ */
+function disconnectLabel(component) {
+  if (!component.labelEl) {
+    return;
+  }
+  const boundOnLabelClick = onLabelClickMap.get(component.labelEl);
+  component.labelEl.removeEventListener(labelClickEvent, boundOnLabelClick);
+  onLabelClickMap.delete(component.labelEl);
+}
+/**
+ * Helper to get the label text from a component.
+ */
+function getLabelText(component) {
+  var _a, _b;
+  return component.label || ((_b = (_a = component.labelEl) === null || _a === void 0 ? void 0 : _a.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || "";
+}
+function onLabelClick(event) {
+  const containedLabelableChildClicked = this.el.contains(event.detail.sourceEvent.target);
+  if (containedLabelableChildClicked) {
+    return;
+  }
+  this.onLabelClick(event);
+}
+
+export { connectLabel as c, disconnectLabel as d, getLabelText as g };

package/dist/components/locale.js

@@ -0,0 +1,118 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+import { a as sanitizeDecimalString } from './number.js';
+
+const locales = [
+  "ar",
+  "bs",
+  "ca",
+  "cs",
+  "da",
+  "de",
+  "de-CH",
+  "el",
+  "en",
+  "en-AU",
+  "en-CA",
+  "en-GB",
+  "es",
+  "es-MX",
+  "et",
+  "fi",
+  "fr",
+  "fr-CH",
+  "he",
+  "hi",
+  "hr",
+  "hu",
+  "id",
+  "it",
+  "it-CH",
+  "ja",
+  "ko",
+  "lt",
+  "lv",
+  "mk",
+  "nb",
+  "nl",
+  "pl",
+  "pt",
+  "pt-PT",
+  "ro",
+  "ru",
+  "sk",
+  "sl",
+  "sr",
+  "sv",
+  "th",
+  "tr",
+  "uk",
+  "vi",
+  "zh-CN",
+  "zh-HK",
+  "zh-TW"
+];
+function createLocaleNumberFormatter(locale) {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 20
+  });
+}
+function delocalizeNumberString(numberString, locale) {
+  if (numberString) {
+    const groupSeparator = getGroupSeparator(locale);
+    const decimalSeparator = getDecimalSeparator(locale);
+    const splitNumberString = numberString.split("");
+    const decimalIndex = splitNumberString.lastIndexOf(decimalSeparator);
+    const delocalizedNumberString = splitNumberString
+      .map((value, index) => {
+      if (value === groupSeparator || (value === decimalSeparator && index !== decimalIndex)) {
+        return "";
+      }
+      return value;
+    })
+      .reduce((string, part) => string + part)
+      .replace(decimalSeparator, ".");
+    return isNaN(Number(delocalizedNumberString)) ? numberString : delocalizedNumberString;
+  }
+  return numberString;
+}
+function getGroupSeparator(locale) {
+  const formatter = createLocaleNumberFormatter(locale);
+  const parts = formatter.formatToParts(1234567.8);
+  const value = parts.find((part) => part.type === "group").value;
+  return value.trim().length === 0 ? " " : value;
+}
+function getDecimalSeparator(locale) {
+  const formatter = createLocaleNumberFormatter(locale);
+  const parts = formatter.formatToParts(1234567.8);
+  const value = parts.find((part) => part.type === "decimal").value;
+  return value.trim().length === 0 ? " " : value;
+}
+function localizeNumberString(numberString, locale, displayGroupSeparator = false) {
+  if (numberString) {
+    const number = Number(sanitizeDecimalString(numberString));
+    if (!isNaN(number)) {
+      const formatter = createLocaleNumberFormatter(locale);
+      const parts = formatter.formatToParts(number);
+      const localizedNumberString = parts
+        .map(({ type, value }) => {
+        switch (type) {
+          case "group":
+            return displayGroupSeparator ? getGroupSeparator(locale) : "";
+          case "decimal":
+            return getDecimalSeparator(locale);
+          default:
+            return value;
+        }
+      })
+        .reduce((string, part) => string + part);
+      return localizedNumberString;
+    }
+  }
+  return numberString;
+}
+
+export { locales as a, delocalizeNumberString as d, getDecimalSeparator as g, localizeNumberString as l };

package/dist/components/math.js

@@ -0,0 +1,7 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+const clamp = (value, min, max) => Math.max(min, Math.min(value, max));
+
+export { clamp as c };

package/dist/components/number.js

@@ -0,0 +1,40 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+import { n as numberKeys } from './key.js';
+
+function isValidNumber(numberString) {
+  return !(!numberString || isNaN(Number(numberString)));
+}
+function parseNumberString(numberString) {
+  if (!numberString || !stringContainsNumbers(numberString)) {
+    return null;
+  }
+  let containsDecimal = false;
+  const result = numberString
+    .split("")
+    .filter((value, i) => {
+    if (value.match(/\./g) && !containsDecimal) {
+      containsDecimal = true;
+      return true;
+    }
+    if (value.match(/\-/g) && i === 0) {
+      return true;
+    }
+    return numberKeys.includes(value);
+  })
+    .reduce((string, part) => string + part);
+  return isValidNumber(result) ? Number(result).toString() : null;
+}
+function sanitizeDecimalString(decimalString) {
+  return (decimalString === null || decimalString === void 0 ? void 0 : decimalString.endsWith(".")) ? decimalString.replace(".", "") : decimalString;
+}
+function sanitizeNumberString(value) {
+  return value ? Number(sanitizeDecimalString(value)).toString() : value;
+}
+function stringContainsNumbers(string) {
+  return numberKeys.some((number) => string.includes(number));
+}
+
+export { sanitizeDecimalString as a, isValidNumber as i, parseNumberString as p, sanitizeNumberString as s };

package/dist/components/observers.js

@@ -0,0 +1,22 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+import { Build } from '@stencil/core/internal/client';
+
+/**
+ * This utility ensures observers are created only for browser contexts.
+ *
+ * @param type - the type of observer to create
+ * @param callback - the observer callback
+ * @param options - the observer options
+ */
+function createObserver(type, callback, options) {
+  const Observer = getObserver(type);
+  return Build.isBrowser ? new Observer(callback, options) : undefined;
+}
+function getObserver(type) {
+  return (type === "intersection" ? IntersectionObserver : type === "mutation" ? MutationObserver : ResizeObserver);
+}
+
+export { createObserver as c };

package/dist/{esm/popper-44055f06.js → components/popper.js}

@@ -2,7 +2,7 @@
  * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
  * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
  */
-import { g as getElementDir } from './dom-70b0e988.js';
+import { a as getElementDir } from './dom.js';
 
 var top = 'top';
 var bottom = 'bottom';
@@ -1769,9 +1769,9 @@ function createPopper({ referenceEl, el, placement, overlayPositioning = "absolu
     modifiers
   });
 }
-function updatePopper({ el, modifiers, placement: PopperPlacement, popper }) {
+async function updatePopper({ el, modifiers, placement: PopperPlacement, popper }) {
   const placement = getPlacement(el, PopperPlacement);
-  popper.setOptions({
+  await popper.setOptions({
     modifiers,
     placement
   });

package/dist/components/resources.js

@@ -0,0 +1,24 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+const CSS = {
+  container: "container",
+  arrow: "arrow",
+  imageContainer: "image-container",
+  closeButton: "close-button",
+  content: "content",
+  hasHeader: "has-header",
+  header: "header",
+  headerContent: "header-content",
+  heading: "heading"
+};
+const TEXT = {
+  close: "Close"
+};
+const POPOVER_REFERENCE = "data-calcite-popover-reference";
+const ARIA_CONTROLS = "aria-controls";
+const ARIA_EXPANDED = "aria-expanded";
+const HEADING_LEVEL = 2;
+
+export { ARIA_EXPANDED as A, CSS as C, HEADING_LEVEL as H, POPOVER_REFERENCE as P, TEXT as T, ARIA_CONTROLS as a };

package/dist/components/resources2.js

@@ -0,0 +1,13 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+const CSS = {
+  container: "container",
+  arrow: "arrow"
+};
+const TOOLTIP_DELAY_MS = 500;
+const TOOLTIP_REFERENCE = "data-calcite-tooltip-reference";
+const ARIA_DESCRIBED_BY = "aria-describedby";
+
+export { ARIA_DESCRIBED_BY as A, CSS as C, TOOLTIP_REFERENCE as T, TOOLTIP_DELAY_MS as a };

package/dist/components/resources3.js

@@ -0,0 +1,18 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+const CSS = {
+  sticky: "sticky"
+};
+var ICON_TYPES;
+(function (ICON_TYPES) {
+  ICON_TYPES["circle"] = "circle";
+  ICON_TYPES["square"] = "square";
+  ICON_TYPES["grip"] = "grip";
+})(ICON_TYPES || (ICON_TYPES = {}));
+const SLOTS = {
+  menuActions: "menu-actions"
+};
+
+export { CSS as C, ICON_TYPES as I, SLOTS as S };

package/dist/components/resources4.js

@@ -0,0 +1,32 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+const CSS = {
+  header: "header",
+  heading: "heading",
+  close: "close",
+  container: "container",
+  tipContainer: "tip-container",
+  tipContainerAdvancing: "tip-container--advancing",
+  tipContainerRetreating: "tip-container--retreating",
+  pagination: "pagination",
+  pagePosition: "page-position",
+  pageNext: "page-next",
+  pagePrevious: "page-previous"
+};
+const ICONS = {
+  chevronLeft: "chevron-left",
+  chevronRight: "chevron-right",
+  close: "x"
+};
+const TEXT = {
+  defaultGroupTitle: "Tips",
+  defaultPaginationLabel: "Tip",
+  close: "Close",
+  previous: "Previous",
+  next: "Next"
+};
+const HEADING_LEVEL = 2;
+
+export { CSS as C, HEADING_LEVEL as H, ICONS as I, TEXT as T };

package/dist/components/shared-list-render.js

@@ -0,0 +1,286 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-components/blob/master/LICENSE.md for details.
+ */
+import { f as focusElement, b as getSlotted, a as getElementDir } from './dom.js';
+import { g as getRoundRobinIndex } from './array.js';
+import { d as debounce } from './debounce.js';
+import { h, Host } from '@stencil/core/internal/client';
+import { C as CSS, S as SLOTS } from './resources3.js';
+
+function mutationObserverCallback() {
+  this.setUpItems();
+  this.setUpFilter();
+}
+const SUPPORTED_ARROW_KEYS = ["ArrowUp", "ArrowDown"];
+// --------------------------------------------------------------------------
+//
+//  Lifecycle
+//
+// --------------------------------------------------------------------------
+function initialize() {
+  this.setUpItems();
+  this.setUpFilter();
+  this.emitCalciteListChange = debounce(internalCalciteListChangeEvent.bind(this), 0);
+}
+function initializeObserver() {
+  var _a;
+  (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.observe(this.el, { childList: true, subtree: true });
+}
+function cleanUpObserver() {
+  var _a;
+  (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+}
+// --------------------------------------------------------------------------
+//
+//  Listeners
+//
+// --------------------------------------------------------------------------
+function calciteListItemChangeHandler(event) {
+  const { selectedValues } = this;
+  const { item, value, selected, shiftPressed } = event.detail;
+  if (selected) {
+    if (this.multiple && shiftPressed) {
+      this.selectSiblings(item);
+    }
+    if (!this.multiple) {
+      this.deselectSiblingItems(item);
+    }
+    selectedValues.set(value, item);
+  }
+  else {
+    selectedValues.delete(value);
+    if (this.multiple && shiftPressed) {
+      this.selectSiblings(item, true);
+    }
+  }
+  if (!this.multiple) {
+    toggleSingleSelectItemTabbing(item, selected);
+    if (selected) {
+      focusElement(item);
+    }
+  }
+  this.lastSelectedItem = item;
+  this.emitCalciteListChange();
+}
+function calciteListItemValueChangeHandler(event) {
+  event.stopPropagation();
+  const oldValue = event.detail.oldValue;
+  const selectedValues = this.selectedValues;
+  if (selectedValues.has(oldValue)) {
+    const item = selectedValues.get(oldValue);
+    selectedValues.delete(oldValue);
+    selectedValues.set(event.detail.newValue, item);
+  }
+}
+// --------------------------------------------------------------------------
+//
+//  Private Methods
+//
+// --------------------------------------------------------------------------
+function isValidNavigationKey(key) {
+  return !!SUPPORTED_ARROW_KEYS.find((k) => k === key);
+}
+function calciteListFocusOutHandler(event) {
+  const { el, items, multiple, selectedValues } = this;
+  if (multiple) {
+    return;
+  }
+  const focusedInside = !!el.contains(event.relatedTarget);
+  if (focusedInside) {
+    toggleSingleSelectItemTabbing(event.target, false);
+    return;
+  }
+  items.forEach((item) => toggleSingleSelectItemTabbing(item, selectedValues.size === 0 ? event.target === item : item.selected));
+}
+function keyDownHandler(event) {
+  const { key, target } = event;
+  if (!isValidNavigationKey(key)) {
+    return;
+  }
+  const { items, multiple, selectionFollowsFocus } = this;
+  const { length: totalItems } = items;
+  const currentIndex = items.indexOf(target);
+  if (!totalItems || currentIndex === -1) {
+    return;
+  }
+  event.preventDefault();
+  const index = getRoundRobinIndex(currentIndex + (key === "ArrowUp" ? -1 : 1), totalItems);
+  const item = items[index];
+  items.forEach((i) => toggleSingleSelectItemTabbing(i, i === item));
+  if (!multiple && selectionFollowsFocus) {
+    item.selected = true;
+  }
+  focusElement(item);
+}
+function internalCalciteListChangeEvent() {
+  this.calciteListChange.emit(this.selectedValues);
+}
+function removeItem(event) {
+  if (event.defaultPrevented) {
+    return;
+  }
+  const item = event.target;
+  const selectedValues = this.selectedValues;
+  if (item.parentElement.tagName === "CALCITE-PICK-LIST-GROUP") {
+    item.parentElement.remove();
+    Array.from(item.parentElement.children).forEach((item) => selectedValues.delete(item.value));
+  }
+  else {
+    item.remove();
+    selectedValues.delete(item.value);
+  }
+  this.emitCalciteListChange();
+}
+function toggleSingleSelectItemTabbing(item, selectable) {
+  // using attribute intentionally
+  if (selectable) {
+    item.removeAttribute("tabindex");
+  }
+  else {
+    item.setAttribute("tabindex", "-1");
+  }
+}
+async function setFocus(focusId) {
+  if (this.filterEnabled && focusId === "filter") {
+    await focusElement(this.filterEl);
+    return;
+  }
+  const { items, multiple, selectionFollowsFocus } = this;
+  if (items.length === 0) {
+    return;
+  }
+  if (multiple) {
+    return items[0].setFocus();
+  }
+  const focusTarget = items.find((item) => item.selected) || items[0];
+  if (selectionFollowsFocus) {
+    focusTarget.selected = true;
+  }
+  return focusTarget.setFocus();
+}
+function setUpItems(tagName) {
+  this.items = Array.from(this.el.querySelectorAll(tagName));
+  let hasSelected = false;
+  const { items } = this;
+  items.forEach((item) => {
+    item.icon = this.getIconType();
+    if (!this.multiple) {
+      item.disableDeselect = true;
+      toggleSingleSelectItemTabbing(item, false);
+    }
+    if (item.selected) {
+      hasSelected = true;
+      toggleSingleSelectItemTabbing(item, true);
+      this.selectedValues.set(item.value, item);
+    }
+  });
+  const [first] = items;
+  if (!hasSelected && first) {
+    toggleSingleSelectItemTabbing(first, true);
+  }
+}
+function deselectSiblingItems(item) {
+  this.items.forEach((currentItem) => {
+    if (currentItem.value !== item.value) {
+      currentItem.toggleSelected(false);
+      if (this.selectedValues.has(currentItem.value)) {
+        this.selectedValues.delete(currentItem.value);
+      }
+    }
+  });
+}
+function selectSiblings(item, deselect = false) {
+  if (!this.lastSelectedItem) {
+    return;
+  }
+  const { items } = this;
+  const start = items.findIndex((currentItem) => {
+    return currentItem.value === this.lastSelectedItem.value;
+  });
+  const end = items.findIndex((currentItem) => {
+    return currentItem.value === item.value;
+  });
+  items.slice(Math.min(start, end), Math.max(start, end)).forEach((currentItem) => {
+    currentItem.toggleSelected(!deselect);
+    if (!deselect) {
+      this.selectedValues.set(currentItem.value, currentItem);
+    }
+    else {
+      this.selectedValues.delete(currentItem.value);
+    }
+  });
+}
+let groups;
+function handleFilter(event) {
+  const filteredData = event.detail;
+  const values = filteredData.map((item) => item.value);
+  let hasSelectedMatch = false;
+  if (!groups) {
+    groups = new Set();
+  }
+  const matchedItems = this.items.filter((item) => {
+    const parent = item.parentElement;
+    const grouped = parent.matches("calcite-pick-list-group");
+    if (grouped) {
+      groups.add(parent);
+    }
+    const matches = values.includes(item.value);
+    item.hidden = !matches;
+    if (!hasSelectedMatch) {
+      hasSelectedMatch = matches && item.selected;
+    }
+    return matches;
+  });
+  groups.forEach((group) => {
+    const hasAtLeastOneMatch = matchedItems.some((item) => group.contains(item));
+    group.hidden = !hasAtLeastOneMatch;
+    if (!hasAtLeastOneMatch) {
+      return;
+    }
+    const parentItem = getSlotted(group, "parent-item");
+    if (parentItem) {
+      parentItem.hidden = false;
+      if (matchedItems.includes(parentItem)) {
+        Array.from(group.children).forEach((child) => (child.hidden = false));
+      }
+    }
+  });
+  groups.clear();
+  if (matchedItems.length > 0 && !hasSelectedMatch && !this.multiple) {
+    toggleSingleSelectItemTabbing(matchedItems[0], true);
+  }
+}
+function getItemData() {
+  return this.items.map((item) => ({
+    label: item.label,
+    description: item.description,
+    metadata: item.metadata,
+    value: item.value
+  }));
+}
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+const List = (_a) => {
+  var { props: { disabled, loading, filterEnabled, dataForFilter, handleFilter, filterPlaceholder, el, setFilterEl } } = _a, rest = __rest(_a, ["props"]);
+  const defaultSlot = h("slot", null);
+  return (h(Host, Object.assign({ "aria-busy": loading.toString(), "aria-disabled": disabled.toString(), role: "menu" }, rest),
+    h("section", null,
+      h("header", { class: { [CSS.sticky]: true } },
+        filterEnabled ? (h("calcite-filter", { "aria-label": filterPlaceholder, data: dataForFilter, dir: getElementDir(el), disabled: loading || disabled, onCalciteFilterChange: handleFilter, placeholder: filterPlaceholder, ref: setFilterEl })) : null,
+        h("slot", { name: SLOTS.menuActions })),
+      loading || disabled ? h("calcite-scrim", { loading: loading }) : null,
+      defaultSlot)));
+};
+
+export { List as L, initializeObserver as a, calciteListItemChangeHandler as b, cleanUpObserver as c, deselectSiblingItems as d, calciteListItemValueChangeHandler as e, calciteListFocusOutHandler as f, getItemData as g, handleFilter as h, initialize as i, setUpItems as j, keyDownHandler as k, setFocus as l, mutationObserverCallback as m, removeItem as r, selectSiblings as s };