@esri/solutions-components 0.6.22 → 0.6.25

package/dist/cjs/interactive-17168f1c.js

@@ -0,0 +1,147 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const browser = require('./browser-09760f9f.js');
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.9.0
+ */
+// ⚠️ browser-sniffing is not a best practice and should be avoided ⚠️
+const isFirefox = /firefox/i.test(browser.getUserAgentString());
+const interactiveElementToParent = isFirefox
+  ? new WeakMap()
+  : null;
+function interceptedClick() {
+  const { disabled } = this;
+  if (!disabled) {
+    HTMLElement.prototype.click.call(this);
+  }
+}
+function onPointerDown(event) {
+  const interactiveElement = event.target;
+  if (isFirefox && !interactiveElementToParent.get(interactiveElement)) {
+    return;
+  }
+  const { disabled } = interactiveElement;
+  if (disabled) {
+    // prevent click from moving focus on host
+    event.preventDefault();
+  }
+}
+const nonBubblingWhenDisabledMouseEvents = ["mousedown", "mouseup", "click"];
+function onNonBubblingWhenDisabledMouseEvent(event) {
+  if (isFirefox && !interactiveElementToParent.get(event.target)) {
+    return;
+  }
+  const { disabled } = event.target;
+  // prevent disallowed mouse events from being emitted on the disabled host (per https://github.com/whatwg/html/issues/5886)
+  //⚠ we generally avoid stopping propagation of events, but this is needed to adhere to the intended spec changes above ⚠
+  if (disabled) {
+    event.stopImmediatePropagation();
+    event.preventDefault();
+  }
+}
+const captureOnlyOptions = { capture: true };
+/**
+ * This helper updates the host element to prevent keyboard interaction on its subtree and sets the appropriate aria attribute for accessibility.
+ *
+ * This should be used in the `componentDidRender` lifecycle hook.
+ *
+ * **Notes**
+ *
+ * this util is not needed for simple components whose root element or elements are an interactive component (custom element or native control). For those cases, set the `disabled` props on the root components instead.
+ * technically, users can override `tabindex` and restore keyboard navigation, but this will be considered user error
+ *
+ * @param component
+ * @param hostIsTabbable
+ */
+function updateHostInteraction(component, hostIsTabbable = false) {
+  if (component.disabled) {
+    component.el.setAttribute("tabindex", "-1");
+    component.el.setAttribute("aria-disabled", "true");
+    if (component.el.contains(document.activeElement)) {
+      document.activeElement.blur();
+    }
+    blockInteraction(component);
+    return;
+  }
+  restoreInteraction(component);
+  if (typeof hostIsTabbable === "function") {
+    component.el.setAttribute("tabindex", hostIsTabbable.call(component) ? "0" : "-1");
+  }
+  else if (hostIsTabbable === true) {
+    component.el.setAttribute("tabindex", "0");
+  }
+  else if (hostIsTabbable === false) {
+    component.el.removeAttribute("tabindex");
+  }
+  else ;
+  component.el.removeAttribute("aria-disabled");
+}
+function blockInteraction(component) {
+  component.el.click = interceptedClick;
+  addInteractionListeners(isFirefox ? getParentElement(component) : component.el);
+}
+function addInteractionListeners(element) {
+  if (!element) {
+    // this path is only applicable to Firefox
+    return;
+  }
+  element.addEventListener("pointerdown", onPointerDown, captureOnlyOptions);
+  nonBubblingWhenDisabledMouseEvents.forEach((event) => element.addEventListener(event, onNonBubblingWhenDisabledMouseEvent, captureOnlyOptions));
+}
+function getParentElement(component) {
+  return interactiveElementToParent.get(component.el);
+}
+function restoreInteraction(component) {
+  delete component.el.click; // fallback on HTMLElement.prototype.click
+  removeInteractionListeners(isFirefox ? getParentElement(component) : component.el);
+}
+function removeInteractionListeners(element) {
+  if (!element) {
+    // this path is only applicable to Firefox
+    return;
+  }
+  element.removeEventListener("pointerdown", onPointerDown, captureOnlyOptions);
+  nonBubblingWhenDisabledMouseEvents.forEach((event) => element.removeEventListener(event, onNonBubblingWhenDisabledMouseEvent, captureOnlyOptions));
+}
+/**
+ * This utility helps disable components consistently in Firefox.
+ *
+ * It needs to be called in `connectedCallback` and is only needed for Firefox as it does not call capture event listeners before non-capture ones (see https://bugzilla.mozilla.org/show_bug.cgi?id=1731504).
+ *
+ * @param component
+ */
+function connectInteractive(component) {
+  if (!component.disabled || !isFirefox) {
+    return;
+  }
+  const parent = component.el.parentElement || component.el; /* assume element is host if it has no parent when connected */
+  interactiveElementToParent.set(component.el, parent);
+  blockInteraction(component);
+}
+/**
+ * This utility restores interactivity to disabled components consistently in Firefox.
+ *
+ * It needs to be called in `disconnectedCallback` and is only needed for Firefox as it does not call capture event listeners before non-capture ones (see https://bugzilla.mozilla.org/show_bug.cgi?id=1731504).
+ *
+ * @param component
+ */
+function disconnectInteractive(component) {
+  if (!isFirefox) {
+    return;
+  }
+  // always remove on disconnect as render or connect will restore it
+  interactiveElementToParent.delete(component.el);
+  restoreInteraction(component);
+}
+
+exports.connectInteractive = connectInteractive;
+exports.disconnectInteractive = disconnectInteractive;
+exports.updateHostInteraction = updateHostInteraction;

package/dist/cjs/it-7c92766b.js

@@ -0,0 +1,65 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-ccb59f65.js');
+require('./index-1ffa261f.js');
+require('./form-88dd1a8a.js');
+require('./dom-c585dfa7.js');
+require('./guid-5ef151a6.js');
+require('./resources-d8917c46.js');
+require('./interactive-17168f1c.js');
+require('./browser-09760f9f.js');
+require('./key-29076628.js');
+require('./label-a44d17b9.js');
+require('./loadable-f8b40373.js');
+require('./locale-62c20bcc.js');
+require('./observers-ee7eadc4.js');
+require('./focusTrapComponent-919e5636.js');
+require('./time-5c558990.js');
+require('./math-1e2752e6.js');
+require('./t9n-47b85291.js');
+require('./openCloseComponent-71c34b2c.js');
+
+// Italian [it]
+var locale = {
+  name: 'it',
+  weekdays: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
+  weekdaysShort: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
+  weekdaysMin: 'do_lu_ma_me_gi_ve_sa'.split('_'),
+  months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
+  weekStart: 1,
+  monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD/MM/YYYY',
+    LL: 'D MMMM YYYY',
+    LLL: 'D MMMM YYYY HH:mm',
+    LLLL: 'dddd D MMMM YYYY HH:mm'
+  },
+  relativeTime: {
+    future: 'tra %s',
+    past: '%s fa',
+    s: 'qualche secondo',
+    m: 'un minuto',
+    mm: '%d minuti',
+    h: 'un\' ora',
+    hh: '%d ore',
+    d: 'un giorno',
+    dd: '%d giorni',
+    M: 'un mese',
+    MM: '%d mesi',
+    y: 'un anno',
+    yy: '%d anni'
+  },
+  ordinal: function ordinal(n) {
+    return n + "\xBA";
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/it-ch-291b8188.js

@@ -0,0 +1,65 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-ccb59f65.js');
+require('./index-1ffa261f.js');
+require('./form-88dd1a8a.js');
+require('./dom-c585dfa7.js');
+require('./guid-5ef151a6.js');
+require('./resources-d8917c46.js');
+require('./interactive-17168f1c.js');
+require('./browser-09760f9f.js');
+require('./key-29076628.js');
+require('./label-a44d17b9.js');
+require('./loadable-f8b40373.js');
+require('./locale-62c20bcc.js');
+require('./observers-ee7eadc4.js');
+require('./focusTrapComponent-919e5636.js');
+require('./time-5c558990.js');
+require('./math-1e2752e6.js');
+require('./t9n-47b85291.js');
+require('./openCloseComponent-71c34b2c.js');
+
+// Italian (Switzerland) [it-ch]
+var locale = {
+  name: 'it-ch',
+  weekdays: 'domenica_lunedì_martedì_mercoledì_giovedì_venerdì_sabato'.split('_'),
+  months: 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
+  weekStart: 1,
+  weekdaysShort: 'dom_lun_mar_mer_gio_ven_sab'.split('_'),
+  monthsShort: 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
+  weekdaysMin: 'do_lu_ma_me_gi_ve_sa'.split('_'),
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'DD.MM.YYYY',
+    LL: 'D MMMM YYYY',
+    LLL: 'D MMMM YYYY HH:mm',
+    LLLL: 'dddd D MMMM YYYY HH:mm'
+  },
+  relativeTime: {
+    future: 'tra %s',
+    past: '%s fa',
+    s: 'alcuni secondi',
+    m: 'un minuto',
+    mm: '%d minuti',
+    h: 'un\'ora',
+    hh: '%d ore',
+    d: 'un giorno',
+    dd: '%d giorni',
+    M: 'un mese',
+    MM: '%d mesi',
+    y: 'un anno',
+    yy: '%d anni'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/ja-3e145c4f.js

@@ -0,0 +1,71 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-ccb59f65.js');
+require('./index-1ffa261f.js');
+require('./form-88dd1a8a.js');
+require('./dom-c585dfa7.js');
+require('./guid-5ef151a6.js');
+require('./resources-d8917c46.js');
+require('./interactive-17168f1c.js');
+require('./browser-09760f9f.js');
+require('./key-29076628.js');
+require('./label-a44d17b9.js');
+require('./loadable-f8b40373.js');
+require('./locale-62c20bcc.js');
+require('./observers-ee7eadc4.js');
+require('./focusTrapComponent-919e5636.js');
+require('./time-5c558990.js');
+require('./math-1e2752e6.js');
+require('./t9n-47b85291.js');
+require('./openCloseComponent-71c34b2c.js');
+
+// Japanese [ja]
+var locale = {
+  name: 'ja',
+  weekdays: '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
+  weekdaysShort: '日_月_火_水_木_金_土'.split('_'),
+  weekdaysMin: '日_月_火_水_木_金_土'.split('_'),
+  months: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+  monthsShort: '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
+  ordinal: function ordinal(n) {
+    return n + "\u65E5";
+  },
+  formats: {
+    LT: 'HH:mm',
+    LTS: 'HH:mm:ss',
+    L: 'YYYY/MM/DD',
+    LL: 'YYYY年M月D日',
+    LLL: 'YYYY年M月D日 HH:mm',
+    LLLL: 'YYYY年M月D日 dddd HH:mm',
+    l: 'YYYY/MM/DD',
+    ll: 'YYYY年M月D日',
+    lll: 'YYYY年M月D日 HH:mm',
+    llll: 'YYYY年M月D日(ddd) HH:mm'
+  },
+  meridiem: function meridiem(hour) {
+    return hour < 12 ? '午前' : '午後';
+  },
+  relativeTime: {
+    future: '%s後',
+    past: '%s前',
+    s: '数秒',
+    m: '1分',
+    mm: '%d分',
+    h: '1時間',
+    hh: '%d時間',
+    d: '1日',
+    dd: '%d日',
+    M: '1ヶ月',
+    MM: '%dヶ月',
+    y: '1年',
+    yy: '%d年'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/key-29076628.js

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.9.0
+ */
+function isActivationKey(key) {
+  return key === "Enter" || key === " ";
+}
+const numberKeys = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+
+exports.isActivationKey = isActivationKey;
+exports.numberKeys = numberKeys;

package/dist/cjs/ko-1b8f5e87.js

@@ -0,0 +1,71 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const calciteInputTimePicker_entry = require('./calcite-input-time-picker-ccb59f65.js');
+require('./index-1ffa261f.js');
+require('./form-88dd1a8a.js');
+require('./dom-c585dfa7.js');
+require('./guid-5ef151a6.js');
+require('./resources-d8917c46.js');
+require('./interactive-17168f1c.js');
+require('./browser-09760f9f.js');
+require('./key-29076628.js');
+require('./label-a44d17b9.js');
+require('./loadable-f8b40373.js');
+require('./locale-62c20bcc.js');
+require('./observers-ee7eadc4.js');
+require('./focusTrapComponent-919e5636.js');
+require('./time-5c558990.js');
+require('./math-1e2752e6.js');
+require('./t9n-47b85291.js');
+require('./openCloseComponent-71c34b2c.js');
+
+// Korean [ko]
+var locale = {
+  name: 'ko',
+  weekdays: '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
+  weekdaysShort: '일_월_화_수_목_금_토'.split('_'),
+  weekdaysMin: '일_월_화_수_목_금_토'.split('_'),
+  months: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
+  monthsShort: '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
+  ordinal: function ordinal(n) {
+    return n + "\uC77C";
+  },
+  formats: {
+    LT: 'A h:mm',
+    LTS: 'A h:mm:ss',
+    L: 'YYYY.MM.DD.',
+    LL: 'YYYY년 MMMM D일',
+    LLL: 'YYYY년 MMMM D일 A h:mm',
+    LLLL: 'YYYY년 MMMM D일 dddd A h:mm',
+    l: 'YYYY.MM.DD.',
+    ll: 'YYYY년 MMMM D일',
+    lll: 'YYYY년 MMMM D일 A h:mm',
+    llll: 'YYYY년 MMMM D일 dddd A h:mm'
+  },
+  meridiem: function meridiem(hour) {
+    return hour < 12 ? '오전' : '오후';
+  },
+  relativeTime: {
+    future: '%s 후',
+    past: '%s 전',
+    s: '몇 초',
+    m: '1분',
+    mm: '%d분',
+    h: '한 시간',
+    hh: '%d시간',
+    d: '하루',
+    dd: '%d일',
+    M: '한 달',
+    MM: '%d달',
+    y: '일 년',
+    yy: '%d년'
+  }
+};
+calciteInputTimePicker_entry.dayjs.locale(locale, null, true);
+
+exports.default = locale;

package/dist/cjs/label-a44d17b9.js

@@ -0,0 +1,154 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const dom = require('./dom-c585dfa7.js');
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.9.0
+ */
+/**
+ * Exported for testing purposes only
+ *
+ * @internal
+ */
+const labelClickEvent = "calciteInternalLabelClick";
+const labelConnectedEvent = "calciteInternalLabelConnected";
+const labelDisconnectedEvent = "calciteInternalLabelDisconnected";
+const labelTagName = "calcite-label";
+const labelToLabelables = new WeakMap();
+const onLabelClickMap = new WeakMap();
+const onLabelConnectedMap = new WeakMap();
+const onLabelDisconnectedMap = new WeakMap();
+const unlabeledComponents = new WeakSet();
+const findLabelForComponent = (componentEl) => {
+  const { id } = componentEl;
+  const forLabel = id && dom.queryElementRoots(componentEl, { selector: `${labelTagName}[for="${id}"]` });
+  if (forLabel) {
+    return forLabel;
+  }
+  const parentLabel = dom.closestElementCrossShadowBoundary(componentEl, labelTagName);
+  if (!parentLabel ||
+    // labelable components within other custom elements are not considered labelable
+    hasAncestorCustomElements(parentLabel, componentEl)) {
+    return null;
+  }
+  return parentLabel;
+};
+function hasAncestorCustomElements(label, componentEl) {
+  let traversedElements;
+  const customElementAncestorCheckEventType = "custom-element-ancestor-check";
+  const listener = (event) => {
+    event.stopImmediatePropagation();
+    const composedPath = event.composedPath();
+    traversedElements = composedPath.slice(composedPath.indexOf(componentEl), composedPath.indexOf(label));
+  };
+  label.addEventListener(customElementAncestorCheckEventType, listener, { once: true });
+  componentEl.dispatchEvent(new CustomEvent(customElementAncestorCheckEventType, { composed: true, bubbles: true }));
+  label.removeEventListener(customElementAncestorCheckEventType, listener);
+  const ancestorCustomElements = traversedElements
+    .filter((el) => el !== componentEl && el !== label)
+    .filter((el) => el.tagName?.includes("-"));
+  return ancestorCustomElements.length > 0;
+}
+/**
+ * Helper to set up label interactions on connectedCallback.
+ *
+ * @param component
+ */
+function connectLabel(component) {
+  const labelEl = findLabelForComponent(component.el);
+  if ((onLabelClickMap.has(labelEl) && labelEl === component.labelEl) ||
+    (!labelEl && unlabeledComponents.has(component))) {
+    return;
+  }
+  const boundOnLabelDisconnected = onLabelDisconnected.bind(component);
+  if (labelEl) {
+    component.labelEl = labelEl;
+    const labelables = labelToLabelables.get(labelEl) || [];
+    labelables.push(component);
+    labelToLabelables.set(labelEl, labelables.sort(sortByDOMOrder));
+    if (!onLabelClickMap.has(component.labelEl)) {
+      onLabelClickMap.set(component.labelEl, onLabelClick);
+      component.labelEl.addEventListener(labelClickEvent, onLabelClick);
+    }
+    unlabeledComponents.delete(component);
+    document.removeEventListener(labelConnectedEvent, onLabelConnectedMap.get(component));
+    onLabelDisconnectedMap.set(component, boundOnLabelDisconnected);
+    document.addEventListener(labelDisconnectedEvent, boundOnLabelDisconnected);
+  }
+  else if (!unlabeledComponents.has(component)) {
+    boundOnLabelDisconnected();
+    document.removeEventListener(labelDisconnectedEvent, onLabelDisconnectedMap.get(component));
+  }
+}
+/**
+ * Helper to tear down label interactions on disconnectedCallback on labelable components.
+ *
+ * @param component
+ */
+function disconnectLabel(component) {
+  unlabeledComponents.delete(component);
+  document.removeEventListener(labelConnectedEvent, onLabelConnectedMap.get(component));
+  document.removeEventListener(labelDisconnectedEvent, onLabelDisconnectedMap.get(component));
+  onLabelConnectedMap.delete(component);
+  onLabelDisconnectedMap.delete(component);
+  if (!component.labelEl) {
+    return;
+  }
+  const labelables = labelToLabelables.get(component.labelEl);
+  if (labelables.length === 1) {
+    component.labelEl.removeEventListener(labelClickEvent, onLabelClickMap.get(component.labelEl));
+    onLabelClickMap.delete(component.labelEl);
+  }
+  labelToLabelables.set(component.labelEl, labelables.filter((labelable) => labelable !== component).sort(sortByDOMOrder));
+  component.labelEl = null;
+}
+function sortByDOMOrder(a, b) {
+  return dom.isBefore(a.el, b.el) ? -1 : 1;
+}
+/**
+ * Helper to get the label text from a component.
+ *
+ * @param component
+ */
+function getLabelText(component) {
+  return component.label || component.labelEl?.textContent?.trim() || "";
+}
+function onLabelClick(event) {
+  const labelClickTarget = event.detail.sourceEvent.target;
+  const labelables = labelToLabelables.get(this);
+  const clickedLabelable = labelables.find((labelable) => labelable.el === labelClickTarget);
+  const labelableChildClicked = labelables.includes(clickedLabelable);
+  if (labelableChildClicked) {
+    // no need to forward click as labelable will receive focus
+    return;
+  }
+  const firstLabelable = labelables[0];
+  if (firstLabelable.disabled) {
+    return;
+  }
+  firstLabelable.onLabelClick(event);
+}
+function onLabelConnected() {
+  if (unlabeledComponents.has(this)) {
+    connectLabel(this);
+  }
+}
+function onLabelDisconnected() {
+  unlabeledComponents.add(this);
+  const boundOnLabelConnected = onLabelConnectedMap.get(this) || onLabelConnected.bind(this);
+  onLabelConnectedMap.set(this, boundOnLabelConnected);
+  document.addEventListener(labelConnectedEvent, boundOnLabelConnected);
+}
+
+exports.connectLabel = connectLabel;
+exports.disconnectLabel = disconnectLabel;
+exports.getLabelText = getLabelText;
+exports.labelConnectedEvent = labelConnectedEvent;
+exports.labelDisconnectedEvent = labelDisconnectedEvent;

package/dist/cjs/loadable-f8b40373.js

@@ -0,0 +1,94 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+const index = require('./index-1ffa261f.js');
+
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v1.9.0
+ */
+const resolveMap = new WeakMap();
+const promiseMap = new WeakMap();
+/**
+ * This helper util sets up the component for the ability to know when the component has been loaded.
+ *
+ * This should be used in the `componentWillLoad` lifecycle hook.
+ *
+ * ```
+ * componentWillLoad(): void {
+ *   setUpLoadableComponent(this);
+ * }
+ * ```
+ *
+ * @param component
+ */
+function setUpLoadableComponent(component) {
+  promiseMap.set(component, new Promise((resolve) => resolveMap.set(component, resolve)));
+}
+/**
+ * This helper util lets the loadable component know that it is now loaded.
+ *
+ * This should be used in the `componentDidLoad` lifecycle hook.
+ *
+ * ```
+ * componentDidLoad(): void {
+ *   setComponentLoaded(this);
+ * }
+ * ```
+ *
+ * @param component
+ */
+function setComponentLoaded(component) {
+  resolveMap.get(component)();
+}
+/**
+ * This helper util can be used to ensure a component has been loaded (The "componentDidLoad" Stencil lifecycle method has been called).
+ *
+ * Requires requires `LoadableComponent` to be implemented.
+ *
+ * A component developer can await this method before proceeding with any logic that requires a component to be loaded first.
+ *
+ * ```
+ * async myMethod(): Promise<void> {
+ *   await componentLoaded(this);
+ * }
+ * ```
+ *
+ * @param component
+ * @returns Promise<void>
+ */
+function componentLoaded(component) {
+  return promiseMap.get(component);
+}
+/**
+ * This helper util can be used to ensuring the component is loaded and rendered by the browser (The "componentDidLoad" Stencil lifecycle method has been called and any internal elements are focusable).
+ *
+ * Requires requires `LoadableComponent` to be implemented.
+ *
+ * A component developer can await this method before proceeding with any logic that requires a component to be loaded first and then an internal element be focused.
+ *
+ * ```
+ * async setFocus(): Promise<void> {
+ *   await componentFocusable(this);
+ *   this.internalElement?.focus();
+ * }
+ * ```
+ *
+ * @param component
+ * @returns Promise<void>
+ */
+async function componentFocusable(component) {
+  await componentLoaded(component);
+  index.forceUpdate(component);
+  return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+}
+
+exports.componentFocusable = componentFocusable;
+exports.componentLoaded = componentLoaded;
+exports.setComponentLoaded = setComponentLoaded;
+exports.setUpLoadableComponent = setUpLoadableComponent;