genesys-spark-components 4.26.1-beta.0 → 4.26.2

package/dist/esm/gux-form-field.service-6bc072f5.js

@@ -1,140 +0,0 @@
-import { h } from './index-39e65a0a.js';
-import { r as randomHTMLId } from './random-html-id-3354d85c.js';
-import { l as logError } from './log-error-0b15023e.js';
-import { s as simulateNativeEvent } from './simulate-native-event-bca7a1c9.js';
-import { h as hasSlot } from './has-slot-d06c74d9.js';
-
-const GuxFormFieldHelp = ({ show }, children) => {
-  return (h("div", { class: {
-      'gux-form-field-help': true,
-      'gux-show': show
-    } },
-    h("div", { class: "gux-message" }, children)));
-};
-
-const GuxFormFieldError = ({ show }, children) => {
-  return (h("div", { class: {
-      'gux-form-field-error': true,
-      'gux-show': show
-    } },
-    h("gux-icon", { "icon-name": "alert-warning-octogon", decorative: true }),
-    h("div", { class: "gux-message" }, children)));
-};
-
-function setInputValue(input, value, focusAfter) {
-  input.value = value;
-  simulateNativeEvent(input, 'input');
-  simulateNativeEvent(input, 'change');
-  if (focusAfter) {
-    input.focus();
-  }
-}
-
-function clearInput(input) {
-  setInputValue(input, '', true);
-}
-function hasContent(input) {
-  return Boolean(input === null || input === void 0 ? void 0 : input.value);
-}
-function getComputedLabelPosition(label, labelPosition) {
-  if (label) {
-    if (['above', 'beside', 'screenreader'].includes(labelPosition)) {
-      return labelPosition;
-    }
-    else if (label.offsetWidth > 1 && label.offsetWidth < 40) {
-      return 'beside';
-    }
-    else {
-      return 'above';
-    }
-  }
-}
-function validateFormIds(root, input) {
-  var _a, _b, _c, _d;
-  if (hasLabelSlot(root)) {
-    const label = root.querySelector('label[slot="label"]');
-    const inputHasId = Boolean(input.hasAttribute('id'));
-    const labelHasFor = Boolean(label.hasAttribute('for'));
-    if (!inputHasId && labelHasFor) {
-      logError(root, 'A "for" attribute has been provided on the label but there is no corresponding id on the input. Either provide an id on the input or omit the "for" attribute from the label. If there is no input id and no "for" attribute provided, the component will automatically generate an id and link it to the "for" attribute.');
-    }
-    else if (!inputHasId) {
-      const defaultInputId = randomHTMLId('gux-form-field-input');
-      input.setAttribute('id', defaultInputId);
-      label.setAttribute('for', defaultInputId);
-    }
-    else if (inputHasId && !labelHasFor) {
-      const forId = input.getAttribute('id');
-      label.setAttribute('for', forId);
-    }
-    else if (inputHasId &&
-      labelHasFor &&
-      input.getAttribute('id') !== label.getAttribute('for')) {
-      logError(root, 'The input id and label for attribute should match.');
-    }
-  }
-  else {
-    logError(root, 'A label is required for this component. If a visual label is not needed for this use case, please add localized text for a screenreader and set the label-position attribute to "screenreader" to visually hide the label.');
-  }
-  if (hasSlot(root, 'error')) {
-    const error = root.querySelector('[slot="error"]');
-    const errorId = randomHTMLId('gux-form-field-error');
-    const describedByIds = ((_a = input
-      .getAttribute('aria-describedby')) === null || _a === void 0 ? void 0 : _a.split(' ').filter(id => !id.startsWith(`gux-form-field-error`))) || [];
-    error.setAttribute('id', errorId);
-    describedByIds.push(errorId);
-    describedByIds &&
-      input.setAttribute('aria-describedby', describedByIds.join(' '));
-  }
-  else if (input.getAttribute('aria-describedby')) {
-    const describedByIds = ((_b = input
-      .getAttribute('aria-describedby')) === null || _b === void 0 ? void 0 : _b.split(' ').filter(id => !id.startsWith(`gux-form-field-error`))) || [];
-    input.setAttribute('aria-describedby', describedByIds.join(' '));
-  }
-  if (hasSlot(root, 'help')) {
-    const help = root.querySelector('[slot="help"]');
-    const helpId = randomHTMLId('gux-form-field-help');
-    const describedByIds = ((_c = input
-      .getAttribute('aria-describedby')) === null || _c === void 0 ? void 0 : _c.split(' ').filter(id => !id.startsWith(`gux-form-field-help`))) || [];
-    help.setAttribute('id', helpId);
-    describedByIds.push(helpId);
-    describedByIds &&
-      input.setAttribute('aria-describedby', describedByIds.join(' '));
-  }
-  else if (input.getAttribute('aria-describedby')) {
-    const describedByIds = ((_d = input
-      .getAttribute('aria-describedby')) === null || _d === void 0 ? void 0 : _d.split(' ').filter(id => !id.startsWith(`gux-form-field-help`))) || [];
-    input.setAttribute('aria-describedby', describedByIds.join(' '));
-  }
-}
-function setSlotAriaAttribute(root, attribute, input, slotName) {
-  var _a;
-  if (hasSlot(root, slotName)) {
-    const slottedElement = root.querySelector(`[slot=${slotName}]`);
-    const randomId = randomHTMLId(`gux-${slotName}`);
-    const ariaAttributeIds = ((_a = input
-      .getAttribute(attribute)) === null || _a === void 0 ? void 0 : _a.split(' ').filter(id => !id.startsWith(`gux-${slotName}`))) || [];
-    slottedElement.setAttribute('id', randomId);
-    ariaAttributeIds === null || ariaAttributeIds === void 0 ? void 0 : ariaAttributeIds.push(randomId);
-    ariaAttributeIds &&
-      input.setAttribute(attribute, ariaAttributeIds.join(' '));
-  }
-}
-function setSlotAriaLabelledby(root, input, slotName) {
-  setSlotAriaAttribute(root, 'aria-labelledby', input, slotName);
-}
-function setSlotAriaDescribedby(root, input, slotName) {
-  setSlotAriaAttribute(root, 'aria-describedby', input, slotName);
-}
-function getSlottedInput(root, inputSelector) {
-  const inputElement = root.querySelector(inputSelector);
-  if (!inputElement) {
-    logError(root, `This component requires an input element that matches the following selector: ${inputSelector}`);
-  }
-  return inputElement;
-}
-function hasLabelSlot(root) {
-  return Boolean(root.querySelector('label[slot="label"]'));
-}
-
-export { GuxFormFieldError as G, GuxFormFieldHelp as a, getComputedLabelPosition as b, setSlotAriaDescribedby as c, clearInput as d, setInputValue as e, getSlottedInput as g, hasContent as h, setSlotAriaLabelledby as s, validateFormIds as v };

package/dist/esm/gux-list.service-693f4ba7.js

@@ -1,73 +0,0 @@
-function getRootChildren(root) {
-  const slot = root.querySelector('slot');
-  return slot ? slot.assignedElements() : Array.from(root.children);
-}
-function getGuxListFocusableItems(root, validFocusableItems) {
-  return getRootChildren(root).filter(cv => {
-    if (validFocusableItems.includes(cv.tagName.toLowerCase())) {
-      return !cv.disabled;
-    }
-    return false;
-  });
-}
-function getCurrentFocusIndex(root, validFocusableItems) {
-  return getGuxListFocusableItems(root, validFocusableItems).findIndex(cv => cv.matches(':focus-within'));
-}
-function getIndexById(root, validFocusableItems, id) {
-  return getGuxListFocusableItems(root, validFocusableItems).findIndex(cv => cv.id === id);
-}
-function getClosestIndexById(root, validFocusableItems, startOfIdString) {
-  const index = getGuxListFocusableItems(root, validFocusableItems).findIndex(cv => cv.id.startsWith(startOfIdString));
-  if (index >= 0) {
-    return index;
-  }
-  return getClosestIndexById(root, validFocusableItems, startOfIdString.slice(0, -1));
-}
-function focusMove(root, validFocusableItems, delta) {
-  const currentFocusIndex = getCurrentFocusIndex(root, validFocusableItems);
-  const maxIndex = getGuxListFocusableItems(root, validFocusableItems).length;
-  focusIndex(root, validFocusableItems, (currentFocusIndex + delta) % maxIndex);
-}
-function focusIndex(root, validFocusableItems, focusIndex) {
-  var _a;
-  const items = getGuxListFocusableItems(root, validFocusableItems);
-  while (focusIndex < 0) {
-    focusIndex += items.length;
-  }
-  (_a = items[focusIndex]) === null || _a === void 0 ? void 0 : _a.focus();
-}
-function getLastChildIndex(root, validFocusableItems) {
-  return getGuxListFocusableItems(root, validFocusableItems).length - 1;
-}
-function first(root, validFocusableItems) {
-  focusIndex(root, validFocusableItems, 0);
-}
-function last(root, validFocusableItems) {
-  focusIndex(root, validFocusableItems, getLastChildIndex(root, validFocusableItems));
-}
-function next(root, validFocusableItems) {
-  focusMove(root, validFocusableItems, 1);
-}
-function previous(root, validFocusableItems) {
-  focusMove(root, validFocusableItems, -1);
-}
-function byId(root, validFocusableItems, id) {
-  const index = getIndexById(root, validFocusableItems, id);
-  if (index >= 0) {
-    focusIndex(root, validFocusableItems, index);
-  }
-  else {
-    focusIndex(root, validFocusableItems, 0);
-  }
-}
-function byClosestId(root, validFocusableItems, id) {
-  const index = getClosestIndexById(root, validFocusableItems, id);
-  if (index >= 0) {
-    focusIndex(root, validFocusableItems, index);
-  }
-  else {
-    focusIndex(root, validFocusableItems, 0);
-  }
-}
-
-export { focusMove as a, byId as b, byClosestId as c, first as f, last as l, next as n, previous as p };

package/dist/esm/gux-listbox.service-8ccb2f73.js

@@ -1,148 +0,0 @@
-function getListOptions(list) {
-  const listChildren = Array.from(list.children);
-  return listChildren.reduce((accumulator, child) => {
-    let childOptions = [];
-    if (isOptionGroup(child)) {
-      childOptions = Array.from(child.children).filter(item => isOption(item));
-    }
-    else if (isOption(child)) {
-      childOptions = [child];
-    }
-    return [...accumulator, ...childOptions];
-  }, []);
-}
-function getAvailableListOptions(list) {
-  return getListOptions(list).filter(option => {
-    return !option.disabled && !option.filtered;
-  });
-}
-function isOptionGroup(item) {
-  return item.tagName === 'GUX-OPTION-GROUP-BETA';
-}
-function isOption(item) {
-  const optionTypes = ['GUX-OPTION', 'GUX-OPTION-ICON', 'GUX-OPTION-MULTI'];
-  return optionTypes.includes(item.tagName);
-}
-function getFirstSelectedOption(list) {
-  return getListOptions(list).find(option => option.selected && !option.disabled && !option.filtered);
-}
-function getActiveOption(list) {
-  return getListOptions(list).find(option => option.active);
-}
-function setActiveOption(list, element) {
-  if (element) {
-    getListOptions(list).forEach(option => {
-      const active = (!option.disabled || !option.filtered) && option === element;
-      option.active = active;
-      if (active) {
-        list.setAttribute('aria-activedescendant', option.id);
-      }
-    });
-    element.scrollIntoView({ block: 'nearest' });
-  }
-}
-function getFirstOption(list) {
-  return getAvailableListOptions(list)[0];
-}
-function getNextOption(list) {
-  if (hasActiveOption(list) && getActiveOption(list) !== getLastOption(list)) {
-    const availableListOptions = getAvailableListOptions(list);
-    const activeOption = getActiveOption(list);
-    const activeOptionIndex = availableListOptions.indexOf(activeOption);
-    return availableListOptions[activeOptionIndex + 1];
-  }
-  return getFirstOption(list);
-}
-function getPreviousOption(list) {
-  if (hasActiveOption(list)) {
-    const availableOptionsList = getAvailableListOptions(list);
-    const activeOptionIndex = availableOptionsList.indexOf(getActiveOption(list));
-    if (getActiveOption(list) === getFirstOption(list)) {
-      return getLastOption(list);
-    }
-    return availableOptionsList[activeOptionIndex - 1];
-  }
-  return getFirstOption(list);
-}
-function getLastOption(list) {
-  const availableOptions = getAvailableListOptions(list);
-  return availableOptions[availableOptions.length - 1];
-}
-function hasActiveOption(list) {
-  return Boolean(getActiveOption(list));
-}
-function getSearchOption(list, searchString) {
-  return getListOptions(list).find(option => {
-    return ((!option.disabled || !option.filtered) &&
-      matchOption(option, searchString));
-  });
-}
-function setSearchOptionActive(list, searchString) {
-  const option = getSearchOption(list, searchString);
-  if (option) {
-    setActiveOption(list, option);
-  }
-}
-function clearActiveOptions(list) {
-  getListOptions(list).forEach(option => {
-    option.active = false;
-  });
-}
-function setInitialActiveOption(list) {
-  setActiveOption(list, getFirstSelectedOption(list) || getFirstOption(list));
-}
-function hasPreviousOption(list) {
-  if (hasActiveOption(list)) {
-    return Boolean(getPreviousOption(list));
-  }
-  return false;
-}
-function hasNextOption(list) {
-  if (hasActiveOption(list)) {
-    return Boolean(getNextOption(list));
-  }
-  return false;
-}
-function setFirstOptionActive(list) {
-  setActiveOption(list, getFirstOption(list));
-}
-function setNextOptionActive(list) {
-  setActiveOption(list, getNextOption(list));
-}
-function setPreviousOptionActive(list) {
-  setActiveOption(list, getPreviousOption(list));
-}
-function setLastOptionActive(list) {
-  setActiveOption(list, getLastOption(list));
-}
-function actOnActiveOption(list, handler) {
-  if (hasActiveOption(list)) {
-    handler(getActiveOption(list).value);
-  }
-}
-function onClickedOption(option, handler) {
-  handler(option.value);
-}
-let timer;
-let searchStringState = '';
-// While there is less than 1s between keypresses that will be considered one search operation.
-// After 1s the next keypress will be considered the start of a new search.
-// This is a mimic/approximation of the native select elements functionality.
-const continueSearchMaxInterval = 1000;
-function goToOption(list, letter) {
-  clearTimeout(timer);
-  searchStringState += letter;
-  setSearchOptionActive(list, searchStringState);
-  timer = setTimeout(() => {
-    searchStringState = '';
-  }, continueSearchMaxInterval);
-}
-function matchOption(option, matchString) {
-  //The text content needs to be trimmed as white space can occur around the textContent if options are populated asynchronously.
-  return option.textContent
-    .trim()
-    .toLowerCase()
-    .startsWith(matchString.toLowerCase());
-}
-
-export { setLastOptionActive as a, setFirstOptionActive as b, clearActiveOptions as c, hasPreviousOption as d, setPreviousOptionActive as e, hasNextOption as f, getSearchOption as g, hasActiveOption as h, setNextOptionActive as i, actOnActiveOption as j, goToOption as k, getListOptions as l, matchOption as m, onClickedOption as o, setInitialActiveOption as s };

package/dist/esm/gux-menu.common-e59a1b12.js

@@ -1,77 +0,0 @@
-const hideDelay = 250;
-function menuNavigation(event, currentElement) {
-  switch (event.key) {
-    case 'ArrowUp':
-      event.stopPropagation();
-      event.preventDefault();
-      focusPreviousSiblingLoop(currentElement);
-      break;
-    case 'ArrowDown':
-      event.stopPropagation();
-      event.preventDefault();
-      focusNextSiblingLoop(currentElement);
-      break;
-    case 'ArrowRight':
-      event.preventDefault();
-      break;
-    case 'ArrowLeft':
-      event.preventDefault();
-      break;
-    case 'Home':
-      event.stopPropagation();
-      event.preventDefault();
-      focusFirstSibling(currentElement);
-      break;
-    case 'End':
-      event.stopPropagation();
-      event.preventDefault();
-      focusLastSibling(currentElement);
-      break;
-  }
-}
-function focusFirstSibling(currentElement) {
-  const firstFocusableElement = getFirstFocusableElement(currentElement);
-  if (firstFocusableElement) {
-    void firstFocusableElement.guxFocus();
-  }
-}
-function focusLastSibling(currentElement) {
-  const lastFocusableElement = getLastFocusableElement(currentElement);
-  if (lastFocusableElement) {
-    void lastFocusableElement.guxFocus();
-  }
-}
-function focusPreviousSiblingLoop(currentElement) {
-  const previousFocusableElement = currentElement.previousElementSibling;
-  if (previousFocusableElement) {
-    void previousFocusableElement.guxFocus();
-  }
-  else {
-    focusLastSibling(currentElement);
-  }
-}
-function focusNextSiblingLoop(currentElement) {
-  const nextFocusableElement = currentElement.nextElementSibling;
-  if (nextFocusableElement) {
-    void nextFocusableElement.guxFocus();
-  }
-  else {
-    focusFirstSibling(currentElement);
-  }
-}
-function getFirstFocusableElement(currentElement) {
-  let firstFocusableElement = currentElement;
-  while (firstFocusableElement.previousElementSibling !== null) {
-    firstFocusableElement = firstFocusableElement.previousElementSibling;
-  }
-  return firstFocusableElement;
-}
-function getLastFocusableElement(currentElement) {
-  let lastFocusableElement = currentElement;
-  while (lastFocusableElement.nextElementSibling !== null) {
-    lastFocusableElement = lastFocusableElement.nextElementSibling;
-  }
-  return lastFocusableElement;
-}
-
-export { hideDelay as h, menuNavigation as m };

package/dist/esm/iso-dates-7bc9d07f.js

@@ -1,25 +0,0 @@
-function asIsoDate(date) {
-  const monthStr = (date.getMonth() + 1).toString().padStart(2, '0');
-  const dateStr = date.getDate().toString().padStart(2, '0');
-  return `${date.getFullYear()}-${monthStr}-${dateStr}`;
-}
-function asIsoDateRange(date1, date2) {
-  const [start, end] = sortedDates([date1, date2]);
-  return `${asIsoDate(start)}/${asIsoDate(end)}`;
-}
-function fromIsoDate(isoDate) {
-  const [yearStr, monthStr, dayStr] = isoDate.split('-');
-  const year = parseInt(yearStr, 10);
-  const month = parseInt(monthStr, 10) - 1; // zero-indexed month
-  const day = parseInt(dayStr, 10);
-  return new Date(year, month, day);
-}
-function fromIsoDateRange(isoDateRange) {
-  const [startIsoDate, endIsoDate] = isoDateRange.split('/');
-  return [fromIsoDate(startIsoDate), fromIsoDate(endIsoDate)];
-}
-function sortedDates(dates) {
-  return dates.sort((d1, d2) => (d1 < d2 ? -1 : 1));
-}
-
-export { asIsoDate as a, asIsoDateRange as b, fromIsoDateRange as c, fromIsoDate as f };

package/dist/esm/log-error-0b15023e.js

@@ -1,8 +0,0 @@
-function logError(component, message) {
-  console.error(`[${component.tagName.toLowerCase()}] ${message}`, component);
-}
-function logWarn(component, message) {
-  console.warn(`[${component.tagName.toLowerCase()}] ${message}`, component);
-}
-
-export { logWarn as a, logError as l };

package/dist/esm/on-attribute-change-42a46627.js

@@ -1,24 +0,0 @@
-function onDisabledChange(element, callback) {
-  const observer = new MutationObserver(mutations => {
-    mutations.forEach(mutation => {
-      if (mutation.attributeName === 'disabled') {
-        callback(element.disabled);
-      }
-    });
-  });
-  observer.observe(element, { attributes: true });
-  return observer;
-}
-function onRequiredChange(element, callback) {
-  const observer = new MutationObserver(mutations => {
-    mutations.forEach(mutation => {
-      if (mutation.attributeName === 'required') {
-        callback(element.required);
-      }
-    });
-  });
-  observer.observe(element, { attributes: true });
-  return observer;
-}
-
-export { onDisabledChange as a, onRequiredChange as o };

package/dist/esm/on-click-outside-f15c5ac7.js

@@ -1,75 +0,0 @@
-import { g as getElement } from './index-39e65a0a.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-const OnClickOutsideOptionsDefaults = {
-  triggerEvents: 'click',
-  exclude: ''
-};
-function OnClickOutside(opt = OnClickOutsideOptionsDefaults) {
-  return (proto, methodName) => {
-    // eslint-disable-next-line
-    const { connectedCallback, disconnectedCallback } = proto;
-    proto.connectedCallback = function () {
-      const host = getElement(this);
-      const method = this[methodName];
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      registerOnClickOutside(this, host, method, opt);
-      return connectedCallback && connectedCallback.call(this);
-    };
-    proto.disconnectedCallback = function () {
-      const host = getElement(this);
-      const method = this[methodName];
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-      removeOnClickOutside(this, host, method, opt);
-      return disconnectedCallback && disconnectedCallback.call(this);
-    };
-  };
-}
-function registerOnClickOutside(component, element, callback, opt = OnClickOutsideOptionsDefaults) {
-  const excludedNodes = getExcludedNodes(opt);
-  getTriggerEvents(opt).forEach(triggerEvent => {
-    window.addEventListener(triggerEvent, (e) => {
-      initOnClickOutside(e, component, element, callback, excludedNodes);
-    }, false);
-  });
-}
-function removeOnClickOutside(component, element, callback, opt = OnClickOutsideOptionsDefaults) {
-  getTriggerEvents(opt).forEach(triggerEvent => {
-    window.removeEventListener(triggerEvent, (e) => {
-      initOnClickOutside(e, component, element, callback);
-    }, false);
-  });
-}
-function initOnClickOutside(event, component, element, callback, excludedNodes) {
-  const composedPath = event.composedPath();
-  if (!composedPath.includes(element) &&
-    !isExcluded(composedPath, excludedNodes) &&
-    element.isConnected) {
-    callback.call(component, event);
-  }
-}
-function getTriggerEvents(opt) {
-  if (opt.triggerEvents) {
-    return opt.triggerEvents.split(',').map(e => e.trim());
-  }
-  return ['click'];
-}
-function getExcludedNodes(opt) {
-  if (opt.exclude) {
-    try {
-      return Array.from(document.querySelectorAll(opt.exclude));
-    }
-    catch (err) {
-      console.warn(`@OnClickOutside: Exclude: '${opt.exclude}' will not be evaluated. Check your exclude selector syntax.`, err);
-    }
-  }
-  return;
-}
-function isExcluded(composedPath, excudedNodes) {
-  if (composedPath && excudedNodes) {
-    return excudedNodes.some(excudedNode => composedPath.includes(excudedNode));
-  }
-  return false;
-}
-
-export { OnClickOutside as O };

package/dist/esm/on-input-disabled-state-change-e6bc912f.js

@@ -1,22 +0,0 @@
-function calculateInputDisabledState(element) {
-  const fieldSet = element.closest('fieldset');
-  return element.disabled || (fieldSet === null || fieldSet === void 0 ? void 0 : fieldSet.disabled);
-}
-
-function onInputDisabledStateChange(element, callback) {
-  const fieldSet = element.closest('fieldset');
-  const observer = new MutationObserver(mutations => {
-    mutations.forEach(mutation => {
-      if (mutation.attributeName === 'disabled') {
-        callback(calculateInputDisabledState(element));
-      }
-    });
-  });
-  observer.observe(element, { attributes: true });
-  if (fieldSet) {
-    observer.observe(fieldSet, { attributes: true });
-  }
-  return observer;
-}
-
-export { calculateInputDisabledState as c, onInputDisabledStateChange as o };

package/dist/esm/on-mutation-a2b7cdad.js

@@ -1,11 +0,0 @@
-function onMutation(element, callback, options = {}) {
-  const observer = new MutationObserver(callback);
-  observer.observe(element, Object.assign({
-    attributes: true,
-    childList: true,
-    subtree: true
-  }, options));
-  return observer;
-}
-
-export { onMutation as o };

package/dist/esm/on-mutation-c570b3ed.js

@@ -1,34 +0,0 @@
-import { g as getElement } from './index-39e65a0a.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-function OnMutation(options) {
-  return (proto, methodName) => {
-    const { connectedCallback, disconnectedCallback } = proto;
-    const store = new Map();
-    proto.connectedCallback = function () {
-      const method = this[methodName];
-      const observer = new MutationObserver(method.bind(this));
-      registerObserver(store, this, observer, options);
-      return connectedCallback && connectedCallback.call(this);
-    };
-    proto.disconnectedCallback = function () {
-      deregisterObserver(store, this);
-      return disconnectedCallback && disconnectedCallback.call(this);
-    };
-  };
-}
-function registerObserver(store, key, observer, options) {
-  if (store.has(key)) {
-    store.get(key).disconnect();
-  }
-  store.set(key, observer);
-  observer.observe(getElement(key), options);
-}
-function deregisterObserver(store, key) {
-  if (store.has(key)) {
-    store.get(key).disconnect();
-  }
-  store.delete(key);
-}
-
-export { OnMutation as O };

package/dist/esm/on-resize-e2132936.js

@@ -1,34 +0,0 @@
-import { g as getElement } from './index-39e65a0a.js';
-
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-function OnResize() {
-  return (proto, methodName) => {
-    const { connectedCallback, disconnectedCallback } = proto;
-    const store = new Map();
-    proto.connectedCallback = function () {
-      const method = this[methodName];
-      const observer = new ResizeObserver(method.bind(this));
-      registerObserver(store, this, observer);
-      return connectedCallback && connectedCallback.call(this);
-    };
-    proto.disconnectedCallback = function () {
-      deregisterObserver(store, this);
-      return disconnectedCallback && disconnectedCallback.call(this);
-    };
-  };
-}
-function registerObserver(store, key, observer) {
-  if (store.has(key)) {
-    store.get(key).disconnect();
-  }
-  store.set(key, observer);
-  observer.observe(getElement(key));
-}
-function deregisterObserver(store, key) {
-  if (store.has(key)) {
-    store.get(key).disconnect();
-  }
-  store.delete(key);
-}
-
-export { OnResize as O };