@odx/foundation 1.0.0-alpha.6 → 1.0.0-alpha.7

package/dist/i18n/lib/is-localized.mixin.js

@@ -1,41 +0,0 @@
-import { SignalWatcher, computed } from '@lit-labs/signals';
-import { dedupeMixin } from '@odx/foundation';
-import { property } from 'lit/decorators.js';
-import { formatDate, formatNumber, formatList, formatRelativeTime } from './format.js';
-import { getLocale } from './localization.js';
-
-var __defProp = Object.defineProperty;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = void 0 ;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(target, key, result) ) || result;
-  if (result) __defProp(target, key, result);
-  return result;
-};
-const IsLocalized = dedupeMixin((superClass) => {
-  class IsLocalizedElement extends SignalWatcher(superClass) {
-    constructor() {
-      super(...arguments);
-      this.locale = computed(() => getLocale(this.lang));
-    }
-    formatDate(...[input, options]) {
-      return formatDate(input, { ...options, locale: options?.locale ?? this.locale.get() });
-    }
-    formatNumber(...[input, options]) {
-      return formatNumber(input, { ...options, locale: options?.locale ?? this.locale.get() });
-    }
-    formatList(...[input, options]) {
-      return formatList(input, { ...options, locale: options?.locale ?? this.locale.get() });
-    }
-    formatRelativeTime(...[input, options]) {
-      return formatRelativeTime(input, { ...options, locale: options?.locale ?? this.locale.get() });
-    }
-  }
-  __decorateClass([
-    property()
-  ], IsLocalizedElement.prototype, "lang");
-  return IsLocalizedElement;
-});
-
-export { IsLocalized };

package/dist/i18n/lib/localization.js

@@ -1,28 +0,0 @@
-import { signal } from '@lit-labs/signals';
-import { createMutationObserver } from '@odx/foundation';
-import { getI18nOptions } from './config.js';
-
-const activeLocale = signal(null, { equals: (t, t2) => t?.toString() === t2?.toString() });
-function watchLocaleChanges(root = document.documentElement) {
-  const updateLocale = () => activeLocale.set(getLocale(root.lang));
-  const observer = createMutationObserver(updateLocale);
-  observer.observe(root, { attributes: true, attributeFilter: ["lang"] });
-  updateLocale();
-}
-function setLocale(locale) {
-  if (locale === null) {
-    document.documentElement.lang = getI18nOptions().defaultLocale().toString();
-  } else {
-    document.documentElement.lang = getLocale(locale).toString();
-  }
-}
-function getLocale(locale) {
-  const fallbackLocale = activeLocale.get() || getI18nOptions().defaultLocale();
-  try {
-    return new Intl.Locale(locale || fallbackLocale);
-  } catch {
-    return new Intl.Locale(fallbackLocale);
-  }
-}
-
-export { getLocale, setLocale, watchLocaleChanges };

package/dist/i18n/lib/translate.js

@@ -1,18 +0,0 @@
-import { signal, computed } from '@lit-labs/signals';
-import { interpolate } from '@odx/foundation';
-import { getLocale } from './localization.js';
-
-const translations = signal({});
-function setTranslation(locale, translation) {
-  const { language } = getLocale(locale);
-  translations.set({ ...translations.get(), [language]: { ...translations.get()[language], ...translation } });
-}
-function translate(key, context, locale) {
-  return computed(() => {
-    const translation = translations.get()[getLocale(locale).language];
-    if (typeof translation?.[key] !== "string") return key;
-    return interpolate(translation[key], { ...translation, ...context });
-  });
-}
-
-export { setTranslation, translate };

package/dist/i18n/main.js

@@ -1,5 +0,0 @@
-export { getI18nOptions, setI18nOptions } from './lib/config.js';
-export { formatDate, formatList, formatNumber, formatRelativeTime } from './lib/format.js';
-export { IsLocalized } from './lib/is-localized.mixin.js';
-export { getLocale, setLocale, watchLocaleChanges } from './lib/localization.js';
-export { setTranslation, translate } from './lib/translate.js';

package/dist/lib/controllers/focus-trap.controller.js

@@ -1,55 +0,0 @@
-import { createFocusTrap } from 'focus-trap';
-import { isServer } from 'lit';
-import { waitForAnimations } from '../utils/dom.js';
-import { createOptions } from '../utils/object.js';
-
-const FocusTrapControllerOptions = createOptions({
-  escapeDeactivates: false,
-  tabbableOptions: { getShadowRoot: true }
-});
-class FocusTrapController {
-  #host;
-  #options;
-  #focusTrap;
-  constructor(host, options) {
-    this.#host = host;
-    this.#options = FocusTrapControllerOptions(options);
-    this.#host.addController(this);
-  }
-  async activate() {
-    await this.#host.updateComplete;
-    this.#focusTrap?.activate();
-  }
-  async deactivate() {
-    await this.#host.updateComplete;
-    this.#focusTrap?.deactivate();
-  }
-  async toggle(state) {
-    if (state ?? !this.#focusTrap?.active) {
-      return this.activate();
-    }
-    return this.deactivate();
-  }
-  async hostConnected() {
-    if (isServer) return;
-    await this.#host.updateComplete;
-    this.#focusTrap ??= createFocusTrap(this.#host, {
-      ...this.#options,
-      checkCanFocusTrap: this.#checkCanFocusTrap.bind(this),
-      checkCanReturnFocus: this.#checkCanReturnFocus.bind(this)
-    });
-  }
-  hostDisconnected() {
-    this.deactivate();
-  }
-  async #checkCanFocusTrap(containers) {
-    await waitForAnimations(this.#host);
-    await this.#options.checkCanFocusTrap?.(containers);
-  }
-  async #checkCanReturnFocus(trigger) {
-    await waitForAnimations(this.#host);
-    await this.#options.checkCanReturnFocus?.(trigger);
-  }
-}
-
-export { FocusTrapController };

package/dist/lib/custom-element.css.js

@@ -1,3 +0,0 @@
-const customElementStyles = "@layer reset,base,variant,state,theme,override;@layer reset{:where(*,*:before,*:after){box-sizing:border-box}body{line-height:1.5;-webkit-font-smoothing:antialiased}img,picture,video,canvas,svg{display:block;max-width:100%;margin:0}input,button,textarea,select{font:inherit;margin:0}p,h1,h2,h3,h4,h5,h6{overflow-wrap:break-word;margin:0}p{text-wrap:pretty;margin:0}h1,h2,h3,h4,h5,h6{text-wrap:balance;margin:0}#root,#__next{isolation:isolate;margin:0}}@layer base{*{scrollbar-color:var(--odx-color-neutral-rest) var(--odx-palette-transparent)}:where(*:not(body)){scrollbar-width:thin}}@layer base{h1,h2,h3,h4,h5,h6{display:block;font-family:var(--odx-typography-font-family-brand);font-size:var(--_font-size);font-weight:var(--odx-typography-font-weight-semibold);line-height:var(--_line-height);color:inherit}h6{--_font-size: var(--odx-breakpoint-font-size-heading-6);--_line-height: var(--odx-breakpoint-line-height-heading-6)}h5{--_font-size: var(--odx-breakpoint-font-size-heading-5);--_line-height: var(--odx-breakpoint-line-height-heading-5)}h4{--_font-size: var(--odx-breakpoint-font-size-heading-4);--_line-height: var(--odx-breakpoint-line-height-heading-4)}h3{--_font-size: var(--odx-breakpoint-font-size-heading-3);--_line-height: var(--odx-breakpoint-line-height-heading-3)}h2{--_font-size: var(--odx-breakpoint-font-size-heading-2);--_line-height: var(--odx-breakpoint-line-height-heading-2)}h1{--_font-size: var(--odx-breakpoint-font-size-heading-1);--_line-height: var(--odx-breakpoint-line-height-heading-1)}[odxPreventTextOverflow]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}}@layer reset{:where(:host){box-sizing:border-box;border:none;color:inherit;outline:none}}";
-
-export { customElementStyles as default };

package/dist/lib/custom-element.js

@@ -1,27 +0,0 @@
-import { LitElement, html, unsafeCSS, CSSResult } from 'lit';
-import customElementStyles from './custom-element.css.js';
-
-function toCSSResult(value) {
-  return value instanceof CSSResult || value instanceof CSSStyleSheet ? value : unsafeCSS(value);
-}
-function customElement(selector, styles = []) {
-  if (selector && globalThis.customElements.get(selector)) return () => void 0;
-  const preparedStyles = [customElementStyles, styles].map(toCSSResult);
-  return (target) => {
-    target.styles = target.styles ? [target.styles, preparedStyles].flat() : preparedStyles;
-    if (selector) {
-      target.selector = selector;
-      customElements.define(target.selector, target);
-    }
-  };
-}
-class CustomElement extends LitElement {
-  render() {
-    return html`<slot></slot>`;
-  }
-  emit(event, eventInit) {
-    return !this.dispatchEvent(new CustomEvent(event, { bubbles: true, composed: true, cancelable: true, ...eventInit }));
-  }
-}
-
-export { CustomElement, customElement };

package/dist/lib/decorators/request-update-on-aria-change.js

@@ -1,15 +0,0 @@
-function ariaPropertyToAttribute(property) {
-  return property.replace("aria", "aria-").replace(/Elements?/g, "").toLowerCase();
-}
-function requestUpdateOnAriaChange(ariaProperties) {
-  return (ctor) => {
-    for (const ariaProperty of ariaProperties) {
-      ctor.createProperty(ariaProperty, {
-        attribute: ariaPropertyToAttribute(ariaProperty),
-        reflect: true
-      });
-    }
-  };
-}
-
-export { requestUpdateOnAriaChange };

package/dist/lib/directives/aria-boolean-attr.js

@@ -1,9 +0,0 @@
-function toAriaBooleanAttribute(value, removeOnFalse = true) {
-  if (removeOnFalse && value === false) return null;
-  return String(value);
-}
-function fromAriaBooleanAttribute(value) {
-  return value === "true";
-}
-
-export { fromAriaBooleanAttribute, toAriaBooleanAttribute };

package/dist/lib/directives/optional-attr.js

@@ -1,8 +0,0 @@
-import { nothing } from 'lit';
-
-const optionalAttr = (value) => {
-  if (value === void 0 || value === null || value === "") return nothing;
-  return value;
-};
-
-export { optionalAttr };

package/dist/lib/directives/optional-slot.js

@@ -1,14 +0,0 @@
-import { html, nothing } from 'lit';
-
-function optionalSlot(host, slotName) {
-  if (host.querySelector(`[slot="${slotName}"]`)) {
-    return html`
-      <div class="${slotName}" part="${slotName}-container">
-        <slot name="${slotName}" @slotchange="${() => host.requestUpdate()}"></slot>
-      </div>
-    `;
-  }
-  return nothing;
-}
-
-export { optionalSlot };

package/dist/lib/directives/slot-fallback.js

@@ -1,16 +0,0 @@
-import { directive, Directive } from 'lit/directive.js';
-import { toggleAttribute } from '../utils/dom.js';
-
-class SlotFallbackDirective extends Directive {
-  update({ options, element }) {
-    const host = options?.host;
-    if (!host || !(element instanceof HTMLSlotElement)) return;
-    const attributeName = ["empty-slot", element.name].filter(Boolean).join("-");
-    toggleAttribute(host, attributeName, !host.textContent?.trim() && element.assignedElements().length === 0);
-  }
-  render() {
-  }
-}
-const emptySlotFallbackFix = directive(SlotFallbackDirective);
-
-export { emptySlotFallbackFix };

package/dist/lib/external/roving-tabindex.js

@@ -1,386 +0,0 @@
-function ensureMethod(value, type, fallback) {
-  if (typeof value === type) {
-    return () => value;
-  } else if (typeof value === "function") {
-    return value;
-  }
-  return fallback;
-}
-class FocusGroupController {
-  constructor(host, { hostDelegatesFocus, direction, elementEnterAction, elements, focusInIndex, isFocusableElement, listenerScope } = {
-    elements: () => []
-  }) {
-    this._currentIndex = -1;
-    this.prevIndex = -1;
-    this._direction = () => "both";
-    this.directionLength = 5;
-    this.hostDelegatesFocus = false;
-    this.elementEnterAction = (_el) => {
-      return;
-    };
-    this._focused = false;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    this._focusInIndex = (_elements) => 0;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    this.isFocusableElement = (_el) => true;
-    this._listenerScope = () => this.host;
-    // When elements are virtualized, the delta between the first element
-    // and the first rendered element.
-    this.offset = 0;
-    this.recentlyConnected = false;
-    this.handleFocusin = (event) => {
-      if (!this.isEventWithinListenerScope(event)) return;
-      const path = event.composedPath();
-      let targetIndex = -1;
-      path.find((el) => {
-        targetIndex = this.elements.indexOf(el);
-        return targetIndex !== -1;
-      });
-      this.prevIndex = this.currentIndex;
-      this.currentIndex = targetIndex > -1 ? targetIndex : this.currentIndex;
-      if (this.isRelatedTargetOrContainAnElement(event)) {
-        this.hostContainsFocus();
-      }
-    };
-    /**
-     * handleClick - Finds the element that was clicked and sets the tabindex to 0
-     * @returns void
-     */
-    this.handleClick = () => {
-      const elements = this.elements;
-      if (!elements.length) return;
-      let focusElement = elements[this.currentIndex];
-      if (this.currentIndex < 0) {
-        return;
-      }
-      if (!focusElement || !this.isFocusableElement(focusElement)) {
-        this.setCurrentIndexCircularly(1);
-        focusElement = elements[this.currentIndex];
-      }
-      if (focusElement && this.isFocusableElement(focusElement)) {
-        elements[this.prevIndex]?.setAttribute("tabindex", "-1");
-        focusElement.setAttribute("tabindex", "0");
-      }
-    };
-    this.handleFocusout = (event) => {
-      if (this.isRelatedTargetOrContainAnElement(event)) {
-        this.hostNoLongerContainsFocus();
-      }
-    };
-    this.handleKeydown = (event) => {
-      if (!this.acceptsEventKey(event.key) || event.defaultPrevented) {
-        return;
-      }
-      let diff = 0;
-      this.prevIndex = this.currentIndex;
-      switch (event.key) {
-        case "ArrowRight":
-          diff += 1;
-          break;
-        case "ArrowDown":
-          diff += this.direction === "grid" ? this.directionLength : 1;
-          break;
-        case "ArrowLeft":
-          diff -= 1;
-          break;
-        case "ArrowUp":
-          diff -= this.direction === "grid" ? this.directionLength : 1;
-          break;
-        case "End":
-          this.currentIndex = 0;
-          diff -= 1;
-          break;
-        case "Home":
-          this.currentIndex = this.elements.length - 1;
-          diff += 1;
-          break;
-      }
-      event.preventDefault();
-      if (this.direction === "grid" && this.currentIndex + diff < 0) {
-        this.currentIndex = 0;
-      } else if (this.direction === "grid" && this.currentIndex + diff > this.elements.length - 1) {
-        this.currentIndex = this.elements.length - 1;
-      } else {
-        this.setCurrentIndexCircularly(diff);
-      }
-      this.elementEnterAction(this.elements[this.currentIndex]);
-      this.focus();
-    };
-    this.mutationObserver = new MutationObserver(() => {
-      this.handleItemMutation();
-    });
-    this.hostDelegatesFocus = hostDelegatesFocus || false;
-    this.host = host;
-    this.host.addController(this);
-    this._elements = elements;
-    this.isFocusableElement = isFocusableElement || this.isFocusableElement;
-    this._direction = ensureMethod(direction, "string", this._direction);
-    this.elementEnterAction = elementEnterAction || this.elementEnterAction;
-    this._focusInIndex = ensureMethod(focusInIndex, "number", this._focusInIndex);
-    this._listenerScope = ensureMethod(listenerScope, "object", this._listenerScope);
-  }
-  get currentIndex() {
-    if (this._currentIndex === -1) {
-      this._currentIndex = this.focusInIndex;
-    }
-    return this._currentIndex - this.offset;
-  }
-  set currentIndex(currentIndex) {
-    this._currentIndex = currentIndex + this.offset;
-  }
-  get direction() {
-    return this._direction();
-  }
-  get elements() {
-    if (!this.cachedElements) {
-      this.cachedElements = this._elements();
-    }
-    return this.cachedElements;
-  }
-  set focused(focused) {
-    if (focused === this.focused) return;
-    this._focused = focused;
-  }
-  get focused() {
-    return this._focused;
-  }
-  get focusInElement() {
-    return this.elements[this.focusInIndex];
-  }
-  get focusInIndex() {
-    return this._focusInIndex(this.elements);
-  }
-  isEventWithinListenerScope(event) {
-    if (this._listenerScope() === this.host) return true;
-    return event.composedPath().includes(this._listenerScope());
-  }
-  /*  In  handleItemMutation() method the first if condition is checking if the element is not focused or if the element's children's length is not decreasing then it means no element has been deleted and we must return.
-        Then we are checking if the deleted element was the focused one before the deletion if so then we need to proceed else we casn return;
-    */
-  handleItemMutation() {
-    if (this._currentIndex == -1 || this.elements.length <= this._elements().length) return;
-    const focusedElement = this.elements[this.currentIndex];
-    this.clearElementCache();
-    if (this.elements.includes(focusedElement)) return;
-    const moveToNextElement = this.currentIndex !== this.elements.length;
-    const diff = moveToNextElement ? 1 : -1;
-    if (moveToNextElement) {
-      this.setCurrentIndexCircularly(-1);
-    }
-    this.setCurrentIndexCircularly(diff);
-    this.focus();
-  }
-  update({ elements } = { elements: () => [] }) {
-    this.unmanage();
-    this._elements = elements;
-    this.clearElementCache();
-    this.manage();
-  }
-  /**
-   * resets the focusedItem to initial item
-   */
-  reset() {
-    const elements = this.elements;
-    if (!elements.length) return;
-    this.setCurrentIndexCircularly(this.focusInIndex - this.currentIndex);
-    let focusElement = elements[this.currentIndex];
-    if (this.currentIndex < 0) {
-      return;
-    }
-    if (!focusElement || !this.isFocusableElement(focusElement)) {
-      this.setCurrentIndexCircularly(1);
-      focusElement = elements[this.currentIndex];
-    }
-    if (focusElement && this.isFocusableElement(focusElement)) {
-      elements[this.prevIndex]?.setAttribute("tabindex", "-1");
-      focusElement.setAttribute("tabindex", "0");
-    }
-  }
-  focusOnItem(item, options) {
-    if (item && this.isFocusableElement(item) && this.elements.indexOf(item)) {
-      const diff = this.elements.indexOf(item) - this.currentIndex;
-      this.setCurrentIndexCircularly(diff);
-      this.elements[this.prevIndex]?.setAttribute("tabindex", "-1");
-    }
-    this.focus(options);
-  }
-  focus(options) {
-    const elements = this.elements;
-    if (!elements.length) return;
-    let focusElement = elements[this.currentIndex];
-    if (!focusElement || !this.isFocusableElement(focusElement)) {
-      this.setCurrentIndexCircularly(1);
-      focusElement = elements[this.currentIndex];
-    }
-    if (focusElement && this.isFocusableElement(focusElement)) {
-      if (!this.hostDelegatesFocus || elements[this.prevIndex] !== focusElement) {
-        elements[this.prevIndex]?.setAttribute("tabindex", "-1");
-      }
-      focusElement.tabIndex = 0;
-      focusElement.focus(options);
-      if (this.hostDelegatesFocus && !this.focused) {
-        this.hostContainsFocus();
-      }
-    }
-  }
-  clearElementCache(offset = 0) {
-    this.mutationObserver.disconnect();
-    delete this.cachedElements;
-    this.offset = offset;
-    requestAnimationFrame(() => {
-      this.elements.forEach((element) => {
-        this.mutationObserver.observe(element, {
-          attributes: true
-        });
-      });
-    });
-  }
-  setCurrentIndexCircularly(diff) {
-    const { length } = this.elements;
-    let steps = length;
-    this.prevIndex = this.currentIndex;
-    let nextIndex = (length + this.currentIndex + diff) % length;
-    while (
-      // don't cycle the elements more than once
-      steps && this.elements[nextIndex] && // @ts-ignore
-      !this.isFocusableElement(this.elements[nextIndex])
-    ) {
-      nextIndex = (length + nextIndex + diff) % length;
-      steps -= 1;
-    }
-    this.currentIndex = nextIndex;
-  }
-  hostContainsFocus() {
-    this.host.addEventListener("focusout", this.handleFocusout);
-    this.host.addEventListener("keydown", this.handleKeydown);
-    this.focused = true;
-  }
-  hostNoLongerContainsFocus() {
-    this.host.addEventListener("focusin", this.handleFocusin);
-    this.host.removeEventListener("focusout", this.handleFocusout);
-    this.host.removeEventListener("keydown", this.handleKeydown);
-    this.focused = false;
-  }
-  isRelatedTargetOrContainAnElement(event) {
-    const relatedTarget = event.relatedTarget;
-    const isRelatedTargetAnElement = this.elements.includes(relatedTarget);
-    const isRelatedTargetContainedWithinElements = this.elements.some((el) => el.contains(relatedTarget));
-    return !(isRelatedTargetAnElement || isRelatedTargetContainedWithinElements);
-  }
-  acceptsEventKey(key) {
-    if (key === "End" || key === "Home") {
-      return true;
-    }
-    switch (this.direction) {
-      case "horizontal":
-        return key === "ArrowLeft" || key === "ArrowRight";
-      case "vertical":
-        return key === "ArrowUp" || key === "ArrowDown";
-      case "both":
-      case "grid":
-        return key.startsWith("Arrow");
-    }
-  }
-  manage() {
-    this.addEventListeners();
-  }
-  unmanage() {
-    this.removeEventListeners();
-  }
-  addEventListeners() {
-    this.host.addEventListener("focusin", this.handleFocusin);
-    this.host.addEventListener("click", this.handleClick);
-  }
-  removeEventListeners() {
-    this.host.removeEventListener("focusin", this.handleFocusin);
-    this.host.removeEventListener("focusout", this.handleFocusout);
-    this.host.removeEventListener("keydown", this.handleKeydown);
-    this.host.removeEventListener("click", this.handleClick);
-  }
-  hostConnected() {
-    this.recentlyConnected = true;
-    this.addEventListeners();
-  }
-  hostDisconnected() {
-    this.mutationObserver.disconnect();
-    this.removeEventListeners();
-  }
-  hostUpdated() {
-    if (this.recentlyConnected) {
-      this.recentlyConnected = false;
-      this.elements.forEach((element) => {
-        this.mutationObserver.observe(element, {
-          attributes: true
-        });
-      });
-    }
-  }
-}
-class RovingTabindexController extends FocusGroupController {
-  constructor() {
-    super(...arguments);
-    this.managed = true;
-    this.manageIndexesAnimationFrame = 0;
-  }
-  set focused(focused) {
-    if (focused === this.focused) return;
-    super.focused = focused;
-    this.manageTabindexes();
-  }
-  get focused() {
-    return super.focused;
-  }
-  clearElementCache(offset = 0) {
-    cancelAnimationFrame(this.manageIndexesAnimationFrame);
-    super.clearElementCache(offset);
-    if (!this.managed) return;
-    this.manageIndexesAnimationFrame = requestAnimationFrame(() => this.manageTabindexes());
-  }
-  manageTabindexes() {
-    if (this.focused && !this.hostDelegatesFocus) {
-      this.updateTabindexes(() => ({ tabIndex: -1 }));
-    } else {
-      this.updateTabindexes((el) => {
-        return {
-          removeTabIndex: el.contains(this.focusInElement) && el !== this.focusInElement,
-          tabIndex: el === this.focusInElement ? 0 : -1
-        };
-      });
-    }
-  }
-  updateTabindexes(getTabIndex) {
-    this.elements.forEach((el) => {
-      const { tabIndex, removeTabIndex } = getTabIndex(el);
-      if (!removeTabIndex) {
-        if (this.focused) {
-          if (el !== this.elements[this.currentIndex]) {
-            el.tabIndex = tabIndex;
-          }
-        } else {
-          el.tabIndex = tabIndex;
-        }
-        return;
-      }
-      const updatable = el;
-      if (updatable.requestUpdate) updatable.requestUpdate();
-    });
-  }
-  manage() {
-    this.managed = true;
-    this.manageTabindexes();
-    super.manage();
-  }
-  unmanage() {
-    this.managed = false;
-    this.updateTabindexes(() => ({ tabIndex: 0 }));
-    super.unmanage();
-  }
-  hostUpdated() {
-    super.hostUpdated();
-    if (!this.host.hasUpdated) {
-      this.manageTabindexes();
-    }
-  }
-}
-
-export { FocusGroupController, RovingTabindexController };