@tale-ui/react 0.0.3

package/esm/utils/InternalBackdrop.js

@@ -0,0 +1,45 @@
+import * as React from 'react';
+
+/**
+ * @internal
+ */
+import { jsx as _jsx } from "react/jsx-runtime";
+export const InternalBackdrop = /*#__PURE__*/React.forwardRef(function InternalBackdrop(props, ref) {
+  const {
+    cutout,
+    ...otherProps
+  } = props;
+  let clipPath;
+  if (cutout) {
+    const rect = cutout?.getBoundingClientRect();
+    clipPath = `polygon(
+      0% 0%,
+      100% 0%,
+      100% 100%,
+      0% 100%,
+      0% 0%,
+      ${rect.left}px ${rect.top}px,
+      ${rect.left}px ${rect.bottom}px,
+      ${rect.right}px ${rect.bottom}px,
+      ${rect.right}px ${rect.top}px,
+      ${rect.left}px ${rect.top}px
+    )`;
+  }
+  return /*#__PURE__*/_jsx("div", {
+    ref: ref,
+    role: "presentation"
+    // Ensures Floating UI's outside press detection runs, as it considers
+    // it an element that existed when the popup rendered.
+    ,
+    "data-tale-ui-inert": "",
+    ...otherProps,
+    style: {
+      position: 'fixed',
+      inset: 0,
+      userSelect: 'none',
+      WebkitUserSelect: 'none',
+      clipPath
+    }
+  });
+});
+if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";

package/esm/utils/adaptiveOriginMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { Middleware } from "../floating-ui-react/index.js";
+export declare const DEFAULT_SIDES: {
+  sideX: string;
+  sideY: string;
+};
+export declare const adaptiveOrigin: Middleware;

package/esm/utils/adaptiveOriginMiddleware.js

@@ -0,0 +1,74 @@
+import { ownerDocument, ownerWindow } from '@tale-ui/utils/owner';
+import { getSide } from '@floating-ui/utils';
+export const DEFAULT_SIDES = {
+  sideX: 'left',
+  sideY: 'top'
+};
+export const adaptiveOrigin = {
+  name: 'adaptiveOrigin',
+  async fn(state) {
+    const {
+      x: rawX,
+      y: rawY,
+      rects: {
+        floating: floatRect
+      },
+      elements: {
+        floating
+      },
+      platform,
+      strategy,
+      placement
+    } = state;
+    const win = ownerWindow(floating);
+    const styles = win.getComputedStyle(floating);
+    const hasTransition = styles.transitionDuration !== '0s' && styles.transitionDuration !== '';
+    if (!hasTransition) {
+      return {
+        x: rawX,
+        y: rawY,
+        data: DEFAULT_SIDES
+      };
+    }
+    const offsetParent = await platform.getOffsetParent?.(floating);
+    let offsetDimensions = {
+      width: 0,
+      height: 0
+    };
+
+    // For fixed strategy, prefer visualViewport if available
+    if (strategy === 'fixed' && win?.visualViewport) {
+      offsetDimensions = {
+        width: win.visualViewport.width,
+        height: win.visualViewport.height
+      };
+    } else if (offsetParent === win) {
+      const doc = ownerDocument(floating);
+      offsetDimensions = {
+        width: doc.documentElement.clientWidth,
+        height: doc.documentElement.clientHeight
+      };
+    } else if (await platform.isElement?.(offsetParent)) {
+      offsetDimensions = await platform.getDimensions(offsetParent);
+    }
+    const currentSide = getSide(placement);
+    let x = rawX;
+    let y = rawY;
+    if (currentSide === 'left') {
+      x = offsetDimensions.width - (rawX + floatRect.width);
+    }
+    if (currentSide === 'top') {
+      y = offsetDimensions.height - (rawY + floatRect.height);
+    }
+    const sideX = currentSide === 'left' ? 'right' : DEFAULT_SIDES.sideX;
+    const sideY = currentSide === 'top' ? 'bottom' : DEFAULT_SIDES.sideY;
+    return {
+      x,
+      y,
+      data: {
+        sideX,
+        sideY
+      }
+    };
+  }
+};

package/esm/utils/areArraysEqual.d.ts

@@ -0,0 +1,3 @@
+type ItemComparer<Item> = (a: Item, b: Item) => boolean;
+export declare function areArraysEqual<Item>(array1: ReadonlyArray<Item>, array2: ReadonlyArray<Item>, itemComparer?: ItemComparer<Item>): boolean;
+export {};

package/esm/utils/areArraysEqual.js

@@ -0,0 +1,3 @@
+export function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {
+  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));
+}

package/esm/utils/clamp.d.ts

@@ -0,0 +1 @@
+export declare function clamp(val: number, min?: number, max?: number): number;

package/esm/utils/clamp.js

@@ -0,0 +1,3 @@
+export function clamp(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  return Math.max(min, Math.min(val, max));
+}

package/esm/utils/collapsibleOpenStateMapping.d.ts

@@ -0,0 +1,11 @@
+import type { StateAttributesMapping } from "./getStateAttributesProps.js";
+export declare const triggerOpenStateMapping: StateAttributesMapping<{
+  open: boolean;
+}>;
+export declare const collapsibleOpenStateMapping: {
+  open(value: boolean): {
+    "data-open": string;
+  } | {
+    "data-closed": string;
+  };
+};

package/esm/utils/collapsibleOpenStateMapping.js

@@ -0,0 +1,26 @@
+import { CollapsiblePanelDataAttributes } from "../collapsible/panel/CollapsiblePanelDataAttributes.js";
+import { CollapsibleTriggerDataAttributes } from "../collapsible/trigger/CollapsibleTriggerDataAttributes.js";
+const PANEL_OPEN_HOOK = {
+  [CollapsiblePanelDataAttributes.open]: ''
+};
+const PANEL_CLOSED_HOOK = {
+  [CollapsiblePanelDataAttributes.closed]: ''
+};
+export const triggerOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return {
+        [CollapsibleTriggerDataAttributes.panelOpen]: ''
+      };
+    }
+    return null;
+  }
+};
+export const collapsibleOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return PANEL_OPEN_HOOK;
+    }
+    return PANEL_CLOSED_HOOK;
+  }
+};

package/esm/utils/constants.d.ts

@@ -0,0 +1,30 @@
+export declare const TYPEAHEAD_RESET_MS = 500;
+export declare const PATIENT_CLICK_THRESHOLD = 500;
+export declare const DISABLED_TRANSITIONS_STYLE: {
+  style: {
+    transition: string;
+  };
+};
+export { EMPTY_OBJECT, EMPTY_ARRAY } from '@tale-ui/utils/empty';
+export declare const CLICK_TRIGGER_IDENTIFIER = "data-tale-ui-click-trigger";
+/**
+ * Used for dropdowns that usually strictly prefer top/bottom placements and
+ * use `var(--available-height)` to limit their height.
+ */
+export declare const DROPDOWN_COLLISION_AVOIDANCE: {
+  readonly fallbackAxisSide: "none";
+};
+/**
+ * Used by regular popups that usually aren't scrollable and are allowed to
+ * freely flip to any axis of placement.
+ */
+export declare const POPUP_COLLISION_AVOIDANCE: {
+  readonly fallbackAxisSide: "end";
+};
+/**
+ * Special visually hidden styles for the aria-owns owner element to ensure owned element
+ * accessibility in iOS/Safari/VoiceControl.
+ * The owner element is an empty span, so most of the common visually hidden styles are not needed.
+ * @see https://github.com/floating-ui/floating-ui/issues/3403
+ */
+export declare const ownerVisuallyHidden: React.CSSProperties;

package/esm/utils/constants.js

@@ -0,0 +1,38 @@
+export const TYPEAHEAD_RESET_MS = 500;
+export const PATIENT_CLICK_THRESHOLD = 500;
+export const DISABLED_TRANSITIONS_STYLE = {
+  style: {
+    transition: 'none'
+  }
+};
+export { EMPTY_OBJECT, EMPTY_ARRAY } from '@tale-ui/utils/empty';
+export const CLICK_TRIGGER_IDENTIFIER = 'data-tale-ui-click-trigger';
+
+/**
+ * Used for dropdowns that usually strictly prefer top/bottom placements and
+ * use `var(--available-height)` to limit their height.
+ */
+export const DROPDOWN_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: 'none'
+};
+
+/**
+ * Used by regular popups that usually aren't scrollable and are allowed to
+ * freely flip to any axis of placement.
+ */
+export const POPUP_COLLISION_AVOIDANCE = {
+  fallbackAxisSide: 'end'
+};
+
+/**
+ * Special visually hidden styles for the aria-owns owner element to ensure owned element
+ * accessibility in iOS/Safari/VoiceControl.
+ * The owner element is an empty span, so most of the common visually hidden styles are not needed.
+ * @see https://github.com/floating-ui/floating-ui/issues/3403
+ */
+export const ownerVisuallyHidden = {
+  clipPath: 'inset(50%)',
+  position: 'fixed',
+  top: 0,
+  left: 0
+};

package/esm/utils/createTaleUIEventDetails.d.ts

@@ -0,0 +1,95 @@
+import { REASONS } from "./reasons.js";
+interface ReasonToEventMap {
+  [REASONS.none]: Event;
+  [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+  [REASONS.triggerHover]: MouseEvent;
+  [REASONS.triggerFocus]: FocusEvent;
+  [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+  [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+  [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+  [REASONS.linkPress]: MouseEvent | PointerEvent;
+  [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+  [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+  [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+  [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+  [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+  [REASONS.inputChange]: InputEvent | Event;
+  [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+  [REASONS.inputBlur]: FocusEvent;
+  [REASONS.inputPaste]: ClipboardEvent;
+  [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+  [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+  [REASONS.escapeKey]: KeyboardEvent;
+  [REASONS.closeWatcher]: Event;
+  [REASONS.listNavigation]: KeyboardEvent;
+  [REASONS.keyboard]: KeyboardEvent;
+  [REASONS.pointer]: PointerEvent;
+  [REASONS.drag]: PointerEvent | TouchEvent;
+  [REASONS.swipe]: PointerEvent | TouchEvent;
+  [REASONS.wheel]: WheelEvent;
+  [REASONS.scrub]: PointerEvent;
+  [REASONS.cancelOpen]: MouseEvent;
+  [REASONS.siblingOpen]: Event;
+  [REASONS.disabled]: Event;
+  [REASONS.imperativeAction]: Event;
+  [REASONS.windowResize]: UIEvent;
+}
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+export type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+type TaleUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+  /**
+   * The reason for the event.
+   */
+  reason: Reason;
+  /**
+   * The native event associated with the custom event.
+   */
+  event: ReasonToEvent<Reason>;
+  /**
+   * Cancels Tale UI from handling the event.
+   */
+  cancel: () => void;
+  /**
+   * Allows the event to propagate in cases where Tale UI will stop the propagation.
+   */
+  allowPropagation: () => void;
+  /**
+   * Indicates whether the event has been canceled.
+   */
+  isCanceled: boolean;
+  /**
+   * Indicates whether the event is allowed to propagate.
+   */
+  isPropagationAllowed: boolean;
+  /**
+   * The element that triggered the event, if applicable.
+   */
+  trigger: Element | undefined;
+} & CustomProperties;
+/**
+ * Details of custom change events emitted by Tale UI components.
+ */
+export type TaleUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? TaleUIChangeEventDetail<Reason, CustomProperties> : never;
+/**
+ * Details of custom generic events emitted by Tale UI components.
+ */
+type TaleUIGenericEventDetail<Reason extends string, CustomProperties extends object> = {
+  /**
+   * The reason for the event.
+   */
+  reason: Reason;
+  /**
+   * The native event associated with the custom event.
+   */
+  event: ReasonToEvent<Reason>;
+} & CustomProperties;
+export type TaleUIGenericEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? TaleUIGenericEventDetail<Reason, CustomProperties> : never;
+/**
+ * Creates a Tale UI event details object with the given reason and utilities
+ * for preventing Tale UI's internal event handling.
+ */
+export declare function createChangeEventDetails<Reason extends string, CustomProperties extends object = {}>(reason: Reason, event?: ReasonToEvent<Reason>, trigger?: HTMLElement, customProperties?: CustomProperties): TaleUIChangeEventDetails<Reason, CustomProperties>;
+export declare function createGenericEventDetails<Reason extends string, CustomProperties extends object = {}>(reason: Reason, event?: ReasonToEvent<Reason>, customProperties?: CustomProperties): TaleUIGenericEventDetails<Reason, CustomProperties>;
+export {};

package/esm/utils/createTaleUIEventDetails.js

@@ -0,0 +1,52 @@
+import { EMPTY_OBJECT } from "./constants.js";
+import { REASONS } from "./reasons.js";
+
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+
+/**
+ * Details of custom change events emitted by Tale UI components.
+ */
+
+/**
+ * Details of custom generic events emitted by Tale UI components.
+ */
+
+/**
+ * Creates a Tale UI event details object with the given reason and utilities
+ * for preventing Tale UI's internal event handling.
+ */
+export function createChangeEventDetails(reason, event, trigger, customProperties) {
+  let canceled = false;
+  let allowPropagation = false;
+  const custom = customProperties ?? EMPTY_OBJECT;
+  const details = {
+    reason,
+    event: event ?? new Event('tale-ui'),
+    cancel() {
+      canceled = true;
+    },
+    allowPropagation() {
+      allowPropagation = true;
+    },
+    get isCanceled() {
+      return canceled;
+    },
+    get isPropagationAllowed() {
+      return allowPropagation;
+    },
+    trigger,
+    ...custom
+  };
+  return details;
+}
+export function createGenericEventDetails(reason, event, customProperties) {
+  const custom = customProperties ?? EMPTY_OBJECT;
+  const details = {
+    reason,
+    event: event ?? new Event('tale-ui'),
+    ...custom
+  };
+  return details;
+}

package/esm/utils/formatNumber.d.ts

@@ -0,0 +1,5 @@
+export declare const cache: Map<string, Intl.NumberFormat>;
+export declare function getFormatter(locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): Intl.NumberFormat;
+export declare function formatNumber(value: number | null, locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+export declare function formatNumberMaxPrecision(value: number | null, locale?: Intl.LocalesArgument, options?: Intl.NumberFormatOptions): string;
+export declare function formatNumberValue(value: number | null, locale?: Intl.LocalesArgument, format?: Intl.NumberFormatOptions): string;

package/esm/utils/formatNumber.js

@@ -0,0 +1,37 @@
+export const cache = new Map();
+export function getFormatter(locale, options) {
+  const optionsString = JSON.stringify({
+    locale,
+    options
+  });
+  const cachedFormatter = cache.get(optionsString);
+  if (cachedFormatter) {
+    return cachedFormatter;
+  }
+  const formatter = new Intl.NumberFormat(locale, options);
+  cache.set(optionsString, formatter);
+  return formatter;
+}
+export function formatNumber(value, locale, options) {
+  if (value == null) {
+    return '';
+  }
+  return getFormatter(locale, options).format(value);
+}
+export function formatNumberMaxPrecision(value, locale, options) {
+  return formatNumber(value, locale, {
+    ...options,
+    maximumFractionDigits: 20
+  });
+}
+export function formatNumberValue(value, locale, format) {
+  if (value == null) {
+    return '';
+  }
+  if (!format) {
+    return formatNumber(value / 100, locale, {
+      style: 'percent'
+    });
+  }
+  return formatNumber(value, locale, format);
+}

package/esm/utils/getCssDimensions.d.ts

@@ -0,0 +1,2 @@
+import { type Dimensions } from '@floating-ui/utils';
+export declare function getCssDimensions(element: Element): Dimensions;

package/esm/utils/getCssDimensions.js

@@ -0,0 +1,21 @@
+import { round } from '@floating-ui/utils';
+import { getComputedStyle, isHTMLElement } from '@floating-ui/utils/dom';
+export function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height
+  };
+}

package/esm/utils/getDisabledMountTransitionStyles.d.ts

@@ -0,0 +1,4 @@
+import type { TransitionStatus } from "./useTransitionStatus.js";
+export declare function getDisabledMountTransitionStyles(transitionStatus: TransitionStatus): {
+  style?: React.CSSProperties | undefined;
+};

package/esm/utils/getDisabledMountTransitionStyles.js

@@ -0,0 +1,4 @@
+import { DISABLED_TRANSITIONS_STYLE, EMPTY_OBJECT } from "./constants.js";
+export function getDisabledMountTransitionStyles(transitionStatus) {
+  return transitionStatus === 'starting' ? DISABLED_TRANSITIONS_STYLE : EMPTY_OBJECT;
+}

package/esm/utils/getPseudoElementBounds.d.ts

@@ -0,0 +1,8 @@
+interface ElementBounds {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+}
+export declare function getPseudoElementBounds(element: HTMLElement): ElementBounds;
+export {};

package/esm/utils/getPseudoElementBounds.js

@@ -0,0 +1,34 @@
+export function getPseudoElementBounds(element) {
+  const elementRect = element.getBoundingClientRect();
+
+  // Avoid "Not implemented: window.getComputedStyle(elt, pseudoElt)"
+  if (process.env.NODE_ENV !== 'production') {
+    return elementRect;
+  }
+  const beforeStyles = window.getComputedStyle(element, '::before');
+  const afterStyles = window.getComputedStyle(element, '::after');
+  const hasPseudoElements = beforeStyles.content !== 'none' || afterStyles.content !== 'none';
+  if (!hasPseudoElements) {
+    return elementRect;
+  }
+
+  // Get dimensions of pseudo-elements
+  const beforeWidth = parseFloat(beforeStyles.width) || 0;
+  const beforeHeight = parseFloat(beforeStyles.height) || 0;
+  const afterWidth = parseFloat(afterStyles.width) || 0;
+  const afterHeight = parseFloat(afterStyles.height) || 0;
+
+  // Calculate max dimensions including pseudo-elements
+  const totalWidth = Math.max(elementRect.width, beforeWidth, afterWidth);
+  const totalHeight = Math.max(elementRect.height, beforeHeight, afterHeight);
+
+  // Calculate the differences to extend the bounds
+  const widthDiff = totalWidth - elementRect.width;
+  const heightDiff = totalHeight - elementRect.height;
+  return {
+    left: elementRect.left - widthDiff / 2,
+    right: elementRect.right + widthDiff / 2,
+    top: elementRect.top - heightDiff / 2,
+    bottom: elementRect.bottom + heightDiff / 2
+  };
+}

package/esm/utils/getStateAttributesProps.d.ts

@@ -0,0 +1,2 @@
+export type StateAttributesMapping<State> = { [Property in keyof State]?: (state: State[Property]) => Record<string, string> | null };
+export declare function getStateAttributesProps<State extends Record<string, any>>(state: State, customMapping?: StateAttributesMapping<State>): Record<string, string>;

package/esm/utils/getStateAttributesProps.js

@@ -0,0 +1,21 @@
+export function getStateAttributesProps(state, customMapping) {
+  const props = {};
+
+  /* eslint-disable-next-line guard-for-in */
+  for (const key in state) {
+    const value = state[key];
+    if (customMapping?.hasOwnProperty(key)) {
+      const customProps = customMapping[key](value);
+      if (customProps != null) {
+        Object.assign(props, customProps);
+      }
+      continue;
+    }
+    if (value === true) {
+      props[`data-${key.toLowerCase()}`] = '';
+    } else if (value) {
+      props[`data-${key.toLowerCase()}`] = value.toString();
+    }
+  }
+  return props;
+}

package/esm/utils/hideMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { type Middleware } from '@floating-ui/react-dom';
+export declare const hide: Middleware;

package/esm/utils/hideMiddleware.js

@@ -0,0 +1,19 @@
+import { hide as nativeHide } from '@floating-ui/react-dom';
+export const hide = {
+  name: 'hide',
+  async fn(state) {
+    const {
+      width,
+      height,
+      x,
+      y
+    } = state.rects.reference;
+    const anchorHidden = width === 0 && height === 0 && x === 0 && y === 0;
+    const nativeHideResult = await nativeHide().fn(state);
+    return {
+      data: {
+        referenceHidden: nativeHideResult.data?.referenceHidden || anchorHidden
+      }
+    };
+  }
+};

package/esm/utils/itemEquality.d.ts

@@ -0,0 +1,6 @@
+export type ItemEqualityComparer<Item = any, Value = Item> = (itemValue: Item, selectedValue: Value) => boolean;
+export declare const defaultItemEquality: ItemEqualityComparer;
+export declare function compareItemEquality<Item, Value>(itemValue: Item, selectedValue: Value, comparer: ItemEqualityComparer<Item, Value>): boolean;
+export declare function selectedValueIncludes<Item, Value>(selectedValues: readonly Item[] | undefined | null, itemValue: Value, comparer: ItemEqualityComparer<Value, Item>): boolean;
+export declare function findItemIndex<Item, Value>(itemValues: readonly Item[] | undefined | null, selectedValue: Value, comparer: ItemEqualityComparer<Item, Value>): number;
+export declare function removeItem<Item, Value>(selectedValues: readonly Item[], itemValue: Value, comparer: ItemEqualityComparer<Value, Item>): Item[];

package/esm/utils/itemEquality.js

@@ -0,0 +1,32 @@
+export const defaultItemEquality = (itemValue, selectedValue) => Object.is(itemValue, selectedValue);
+export function compareItemEquality(itemValue, selectedValue, comparer) {
+  if (itemValue == null || selectedValue == null) {
+    return Object.is(itemValue, selectedValue);
+  }
+  return comparer(itemValue, selectedValue);
+}
+export function selectedValueIncludes(selectedValues, itemValue, comparer) {
+  if (!selectedValues || selectedValues.length === 0) {
+    return false;
+  }
+  return selectedValues.some(selectedValue => {
+    if (selectedValue === undefined) {
+      return false;
+    }
+    return compareItemEquality(itemValue, selectedValue, comparer);
+  });
+}
+export function findItemIndex(itemValues, selectedValue, comparer) {
+  if (!itemValues || itemValues.length === 0) {
+    return -1;
+  }
+  return itemValues.findIndex(itemValue => {
+    if (itemValue === undefined) {
+      return false;
+    }
+    return compareItemEquality(itemValue, selectedValue, comparer);
+  });
+}
+export function removeItem(selectedValues, itemValue, comparer) {
+  return selectedValues.filter(selectedValue => !compareItemEquality(itemValue, selectedValue, comparer));
+}

package/esm/utils/noop.d.ts

@@ -0,0 +1 @@
+export { NOOP } from '@tale-ui/utils/empty';

package/esm/utils/noop.js

@@ -0,0 +1 @@
+export { NOOP } from '@tale-ui/utils/empty';