mimir-ui-kit 1.38.36 → 1.38.39

package/dist/components/MessageShortReply/MessageShortReply.d.ts

@@ -0,0 +1,30 @@
+import { ComponentProps } from 'react';
+import { EMessageShortReplyVariant } from './constants';
+import { TIcon } from '../../icons';
+
+export type TProps = ComponentProps<'button'> & {
+    /**
+     * Класс, применяемый к корневому элементу MessageShortReply.
+     */
+    className?: string;
+    /**
+     * Флаг, указывающий, отключена ли MessageShortReply.
+     */
+    disabled?: boolean;
+    /**
+     * "Вариант отображения MessageShortReply. Допустимые значения: 'sapphire', sapphire-filled', 'citrine', 'asphalt', 'gray', 'white', 'green'."
+     */
+    variant?: `${EMessageShortReplyVariant}` | EMessageShortReplyVariant;
+    /**
+     * Имя иконки слева.
+     */
+    leftIconName?: TIcon;
+    /**
+     * Имя иконки справа.
+     */
+    rightIconName?: TIcon;
+};
+/**
+ * Компонент MessageShortReply, который можно настраивать с различными темами и размерами.
+ */
+export declare const MessageShortReply: import('react').ForwardRefExoticComponent<Omit<TProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/MessageShortReply/MessageShortReply.js

@@ -0,0 +1,51 @@
+import { jsxs as d, jsx as a } from "react/jsx-runtime";
+import { c as y } from "../../index-DIxK0V-G.js";
+import { forwardRef as f } from "react";
+import { EMessageShortReplyVariant as g } from "./constants.js";
+import { Icon as o } from "../../icons/Icon.js";
+import '../../assets/MessageShortReply.css';const N = "_sapphire_1tpxx_50", b = "_citrine_1tpxx_67", u = "_asphalt_1tpxx_76", w = "_gray_1tpxx_85", R = "_white_1tpxx_94", S = "_green_1tpxx_103", I = "_disabled_1tpxx_112", e = {
+  "short-reply": "_short-reply_1tpxx_2",
+  sapphire: N,
+  "sapphire-filled": "_sapphire-filled_1tpxx_59",
+  citrine: b,
+  asphalt: u,
+  gray: w,
+  white: R,
+  green: S,
+  disabled: I
+}, M = f(
+  (p, i) => {
+    const {
+      variant: n = g.Sapphire,
+      children: c,
+      className: l,
+      leftIconName: s,
+      rightIconName: r,
+      type: _ = "button",
+      disabled: t,
+      ...h
+    } = p, x = {
+      [e.disabled]: t,
+      [e[n]]: !t
+    }, m = y(l, e["short-reply"], x);
+    return /* @__PURE__ */ d(
+      "button",
+      {
+        type: _,
+        disabled: t,
+        ref: i,
+        className: m,
+        ...h,
+        children: [
+          s && /* @__PURE__ */ a(o, { iconName: s }),
+          c,
+          r && /* @__PURE__ */ a(o, { iconName: r })
+        ]
+      }
+    );
+  }
+);
+M.displayName = "MessageShortReply";
+export {
+  M as MessageShortReply
+};

package/dist/components/MessageShortReply/constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum EMessageShortReplyVariant {
+    Sapphire = "sapphire",
+    SapphireFilled = "sapphire-filled",
+    Citrine = "citrine",
+    Asphalt = "asphalt",
+    Gray = "gray",
+    White = "white",
+    Green = "green"
+}

package/dist/components/MessageShortReply/constants.js

@@ -0,0 +1,4 @@
+var p = /* @__PURE__ */ ((i) => (i.Sapphire = "sapphire", i.SapphireFilled = "sapphire-filled", i.Citrine = "citrine", i.Asphalt = "asphalt", i.Gray = "gray", i.White = "white", i.Green = "green", i))(p || {});
+export {
+  p as EMessageShortReplyVariant
+};

package/dist/components/MessageShortReply/index.d.ts

@@ -0,0 +1,2 @@
+export { MessageShortReply, type TProps as TMessageShortReplyProps } from './MessageShortReply';
+export { EMessageShortReplyVariant } from './constants';

package/dist/components/MessageShortReply/index.js

@@ -0,0 +1,6 @@
+import { MessageShortReply as o } from "./MessageShortReply.js";
+import { EMessageShortReplyVariant as a } from "./constants.js";
+export {
+  a as EMessageShortReplyVariant,
+  o as MessageShortReply
+};

package/dist/components/MultiSelectSearch/MultiSelectSearch.d.ts

@@ -0,0 +1,26 @@
+import { EMultiSelectSearchSize } from './constants';
+import { TMultiSelectOption } from './types';
+
+export declare const MultiSelectSearch: import('react').ForwardRefExoticComponent<Pick<import('../Input').TInputProps, "variant" | "withClearButton"> & {
+    value?: TMultiSelectOption[] | null;
+    onChange?: (value: TMultiSelectOption[]) => void;
+    placeholder?: string;
+    size?: EMultiSelectSearchSize;
+    full?: boolean;
+    displayValue?: string;
+    showArrow?: boolean;
+    onSearch?: (value: string) => void;
+    filterOnSearch?: boolean;
+    items: TMultiSelectOption[];
+    classNameOption?: string;
+    menuPlacement?: import('./types').TMenuPlacement;
+    disabled?: boolean;
+    searchProps?: Pick<import('../Input').TInputProps, "numbersOnly" | "maxLength" | "required">;
+    withChip?: boolean;
+    chipVariant?: import('../Chip').EChipVariant | `${import('../Chip').EChipVariant}`;
+    disableInput?: boolean;
+    autocomplete?: "on" | "off";
+    id?: string;
+    autoPlacement?: boolean;
+    onIsOpen?: (value: boolean) => void;
+} & import('react').RefAttributes<HTMLElement>>;

package/dist/components/MultiSelectSearch/MultiSelectSearch.js

@@ -0,0 +1,375 @@
+import { jsxs as E, jsx as n, Fragment as Y } from "react/jsx-runtime";
+import { c as u } from "../../index-DIxK0V-G.js";
+import { forwardRef as Ne, useId as Se, useRef as P, useState as g, useEffect as y, useMemo as Ce, useCallback as Me } from "react";
+import { EMultiSelectSearchSize as R } from "./constants.js";
+import { getInitialInputValue as Z, shouldShowMenuOnTop as Ee, MULTISELECT_OPEN_EVENT as ee, mapSizeToInputSize as te, getDropdownArrowIcon as Le, dispatchMultiselectOpen as L, joinSelectedItems as oe } from "./utils.js";
+import { Icon as ye } from "../../icons/Icon.js";
+import { Button as ke } from "../Button/Button.js";
+import { CheckboxMimir as Te } from "../CheckboxMimir/CheckboxMimir.js";
+import { Chip as Oe } from "../Chip/Chip.js";
+import { I as ne } from "../../Input-DAmc_HxO.js";
+import { EInputVariant as ze } from "../Input/constants.js";
+import { H as Ae, U as ie, G as se, K as Ve, W as qe } from "../../combobox-CVtJDVoZ.js";
+import '../../assets/MultiSelectSearch.css';const xe = "_disabled_io0c8_5", De = "_container_io0c8_9", Pe = "_full_io0c8_27", Re = "_button_io0c8_39", Be = "_options_io0c8_53", Fe = "_visible_io0c8_66", Je = "_top_io0c8_69", je = "_bottom_io0c8_74", Ge = "_m_io0c8_2", He = "_l_io0c8_116", Ue = "_focused_io0c8_134", We = "_option_io0c8_53", Ke = "_chip_io0c8_163", $e = "_clear_io0c8_188", e = {
+  "multi-select-search": "_multi-select-search_io0c8_2",
+  disabled: xe,
+  container: De,
+  "container-open": "_container-open_io0c8_18",
+  "input-container": "_input-container_io0c8_22",
+  full: Pe,
+  "selected-icon": "_selected-icon_io0c8_31",
+  "selector-icon-open": "_selector-icon-open_io0c8_35",
+  button: Re,
+  "selector-icon": "_selector-icon_io0c8_35",
+  options: Be,
+  visible: Fe,
+  top: Je,
+  bottom: je,
+  "no-options": "_no-options_io0c8_95",
+  m: Ge,
+  l: He,
+  "multi-select-input-disabled": "_multi-select-input-disabled_io0c8_131",
+  "multi-select-input": "_multi-select-input_io0c8_131",
+  focused: Ue,
+  option: We,
+  "option-active": "_option-active_io0c8_153",
+  "option-inner": "_option-inner_io0c8_156",
+  chip: Ke,
+  "chip-container": "_chip-container_io0c8_168",
+  "chip-root": "_chip-root_io0c8_174",
+  "right-slot": "_right-slot_io0c8_178",
+  "required-mark": "_required-mark_io0c8_183",
+  clear: $e,
+  "icon-button": "_icon-button_io0c8_197"
+}, at = Ne(
+  (ce, re) => {
+    const {
+      placeholder: B,
+      size: i = R.L,
+      value: m,
+      onChange: s,
+      full: le,
+      showArrow: ae = !0,
+      items: f = [],
+      classNameOption: ue,
+      displayValue: v = "name",
+      filterOnSearch: F = !0,
+      onSearch: k,
+      variant: J = ze.DefaultGray,
+      menuPlacement: w = "bottom",
+      disabled: d = !1,
+      searchProps: j,
+      withClearButton: T = !1,
+      withChip: de = !1,
+      chipVariant: pe = "sapphire",
+      disableInput: I = !1,
+      autocomplete: G = "on",
+      id: me,
+      autoPlacement: O = !1,
+      onIsOpen: r
+    } = ce, _e = Se(), _ = me || `multiselect-${_e}`, N = P(null), b = P(null), z = P(!1), [l, h] = g(!1), [S, C] = g(
+      () => Z(m, v)
+    ), [c, M] = g(
+      m || []
+    ), [A, H] = g(w), [V, U] = g(!1), [he, W] = g(!1);
+    y(() => {
+      m && (M(m), JSON.stringify(m) !== JSON.stringify(c) && C(Z(m, v)));
+    }, [m, v, c]);
+    const K = Ce(() => {
+      var o;
+      if (!F) return f;
+      const t = ((o = S.split(",").pop()) == null ? void 0 : o.trim().toLowerCase()) ?? "";
+      return c.length > 0 && c[c.length - 1].name.toLowerCase() === t ? f : f.filter(
+        (a) => a.name.toLowerCase().includes(t)
+      );
+    }, [F, f, S, c]), fe = (t) => {
+      M(t), s == null || s(t);
+      const o = oe(t, v);
+      C(o), h(!0), L(_), setTimeout(() => {
+        if (b.current) {
+          b.current.focus(), b.current.scrollLeft = b.current.scrollWidth;
+          const a = o.length;
+          b.current.setSelectionRange(a, a);
+        }
+      }, 0);
+    }, $ = (t) => {
+      var X;
+      if (I) return;
+      const o = t.target.value;
+      C(o), k == null || k(o);
+      const a = o.split(",").map((D) => D.trim()).filter(Boolean), q = f.filter(
+        (D) => a.includes(D[v])
+      );
+      JSON.stringify(q) !== JSON.stringify(c) && (M(q), s == null || s(q)), h(!0), L(_);
+      const x = (X = N.current) == null ? void 0 : X.querySelector(
+        `.${e.options}`
+      );
+      x && typeof x.scrollTo == "function" && x.scrollTo({ top: 0, behavior: "smooth" });
+    }, ve = (t) => {
+      const o = c.filter(
+        (a) => a.id !== t.id
+      );
+      M(o), s == null || s(o), C(oe(o, v));
+    }, p = Me(() => {
+      if (!O) {
+        H(w);
+        return;
+      }
+      const t = Ee(N, i);
+      H(t ? "top" : w);
+    }, [O, w, i]), Q = () => {
+      const t = !l;
+      t && (p(), L(_)), h(t), r == null || r(t);
+    }, be = (t) => {
+      t.preventDefault(), t.currentTarget.focus();
+      const o = t.currentTarget.value.length;
+      t.currentTarget.setSelectionRange(o, o);
+    }, ge = () => {
+      C(""), M([]), s == null || s([]);
+    }, we = (t) => {
+      t.stopPropagation(), ge();
+    }, Ie = (t) => {
+      if (I) {
+        t.target.blur();
+        return;
+      }
+      p(), h(!0), L(_);
+    };
+    return y(() => {
+      if (l) {
+        const t = (o) => {
+          N.current && !N.current.contains(o.target) && !o.defaultPrevented && (h(!1), r == null || r(!1));
+        };
+        return document.addEventListener("mousedown", t), () => {
+          document.removeEventListener("mousedown", t);
+        };
+      }
+    }, [l, r]), y(() => {
+      const o = (a) => {
+        a.detail === _ || !l || z.current || (z.current = !0, h(!1), r == null || r(!1), queueMicrotask(() => {
+          z.current = !1;
+        }));
+      };
+      return window.addEventListener(ee, o), () => window.removeEventListener(ee, o);
+    }, [_, r, l]), y(() => {
+      if (l) {
+        p(), window.addEventListener("scroll", p), window.addEventListener("resize", p);
+        const t = requestAnimationFrame(() => {
+          W(!0), U(!0);
+        });
+        return () => {
+          window.removeEventListener("scroll", p), window.removeEventListener("resize", p), cancelAnimationFrame(t);
+        };
+      } else
+        U(!1), W(!1);
+    }, [l, w, O, i, p]), /* @__PURE__ */ E("div", { ref: N, children: [
+      /* @__PURE__ */ n(
+        Ae,
+        {
+          multiple: !0,
+          as: "div",
+          value: c,
+          className: u(e["multi-select-search"], {
+            [e.full]: le,
+            [e.disabled]: d
+          }),
+          onChange: fe,
+          ref: re,
+          disabled: d,
+          virtual: { options: K },
+          children: /* @__PURE__ */ E(
+            "div",
+            {
+              className: u(e.container, e[i], {
+                [e["container-open"]]: l
+              }),
+              children: [
+                I && /* @__PURE__ */ E("div", { className: e["input-container"], children: [
+                  /* @__PURE__ */ n(
+                    ie,
+                    {
+                      disabled: d,
+                      style: { width: "100%" },
+                      onClick: Q,
+                      children: /* @__PURE__ */ n(
+                        se,
+                        {
+                          as: ne,
+                          label: B,
+                          size: te(i),
+                          className: u(e["multi-select-input"], {
+                            [e["multi-select-input-disabled"]]: I && T
+                          }),
+                          onChange: $,
+                          value: S,
+                          disabled: d,
+                          variant: J,
+                          rightSlotClassName: e["right-slot"],
+                          requiredMarkClassName: e["required-mark"],
+                          "data-testid": "select-search-input",
+                          onFocus: Ie,
+                          rightAddon: {
+                            addonType: "icon",
+                            addonContent: Le(l, i)
+                          },
+                          autocomplete: G,
+                          ...j
+                        }
+                      )
+                    }
+                  ),
+                  T && S && /* @__PURE__ */ n(
+                    ke,
+                    {
+                      tabIndex: -1,
+                      className: u(e.clear, {
+                        [e.disabled]: d
+                      }),
+                      iconButtonClassName: e["icon-button"],
+                      isIconButton: !0,
+                      iconName: "Close16px",
+                      size: "m-s",
+                      clear: !0,
+                      disabled: d,
+                      variant: "secondary-gray",
+                      onClick: we,
+                      "data-testid": "clear-button"
+                    }
+                  )
+                ] }),
+                !I && /* @__PURE__ */ n(
+                  se,
+                  {
+                    as: ne,
+                    label: B,
+                    size: te(i),
+                    className: e["multi-select-input"],
+                    rightSlotClassName: e["right-slot"],
+                    requiredMarkClassName: e["required-mark"],
+                    value: S,
+                    disabled: d,
+                    variant: J,
+                    withClearButton: T,
+                    onFocus: () => {
+                      h(!0), L(_);
+                    },
+                    onMouseDown: be,
+                    onChange: $,
+                    ref: b,
+                    rightAddon: {
+                      addonType: "react-node",
+                      addonContent: ae && /* @__PURE__ */ n(
+                        ie,
+                        {
+                          className: u(e.button, {
+                            [e.disabled]: d
+                          }),
+                          disabled: d,
+                          onMouseDown: Q,
+                          children: /* @__PURE__ */ n(
+                            ye,
+                            {
+                              iconName: i == R.M ? "DropdownArrowBottom16px" : "DropdownArrowDown24px",
+                              className: u(e["selector-icon"], {
+                                [e["selector-icon-open"]]: l
+                              })
+                            }
+                          )
+                        }
+                      )
+                    },
+                    "data-testid": "select-search-input",
+                    autocomplete: G,
+                    ...j
+                  }
+                ),
+                l && he && /* @__PURE__ */ n(Y, { children: f.length ? K.length ? /* @__PURE__ */ n(
+                  Ve,
+                  {
+                    className: u(
+                      e.options,
+                      e[i],
+                      e[A],
+                      { [e.visible]: V }
+                    ),
+                    modal: !1,
+                    static: !0,
+                    children: ({ option: t }) => /* @__PURE__ */ n(
+                      qe,
+                      {
+                        value: t,
+                        className: ({ focus: o }) => u(
+                          e.option,
+                          ue,
+                          i && e[i],
+                          {
+                            [e["option-active"]]: o
+                          }
+                        ),
+                        children: /* @__PURE__ */ E(Y, { children: [
+                          /* @__PURE__ */ E("div", { className: e["option-inner"], children: [
+                            t.name,
+                            t.bottom && /* @__PURE__ */ n("div", { children: t.bottom })
+                          ] }),
+                          /* @__PURE__ */ n(
+                            Te,
+                            {
+                              isInteractive: !1,
+                              checked: c.some(
+                                (o) => o.id === t.id
+                              )
+                            }
+                          )
+                        ] })
+                      },
+                      t.id
+                    )
+                  }
+                ) : /* @__PURE__ */ n(
+                  "div",
+                  {
+                    className: u(
+                      e.options,
+                      e[i],
+                      e["no-options"],
+                      e[A],
+                      { [e.visible]: V }
+                    ),
+                    children: "Ничего не найдено"
+                  }
+                ) : /* @__PURE__ */ n(
+                  "div",
+                  {
+                    className: u(
+                      e.options,
+                      e[i],
+                      e["no-options"],
+                      e[A],
+                      { [e.visible]: V }
+                    ),
+                    children: "Нет данных"
+                  }
+                ) })
+              ]
+            }
+          )
+        }
+      ),
+      de && c.length > 0 && /* @__PURE__ */ n("div", { className: e["chip-container"], children: c.map((t) => /* @__PURE__ */ n(
+        Oe,
+        {
+          size: i === R.L ? "s" : "xs",
+          variant: pe,
+          className: e["chip-root"],
+          withAction: !0,
+          onClose: () => ve(t),
+          children: /* @__PURE__ */ n("span", { className: e.chip, children: t.name })
+        },
+        t.id
+      )) })
+    ] });
+  }
+);
+export {
+  at as MultiSelectSearch
+};

package/dist/components/MultiSelectSearch/constants.d.ts

@@ -0,0 +1,7 @@
+export declare enum EMultiSelectSearchSize {
+    M = "m",
+    L = "l"
+}
+export declare const MOBILE_BREAKPOINT = 767;
+export declare const MOBILE_MENU_HEIGHT = 264;
+export declare const DESKTOP_MENU_HEIGHT = 320;

package/dist/components/MultiSelectSearch/constants.js

@@ -0,0 +1,8 @@
+var I = /* @__PURE__ */ ((E) => (E.M = "m", E.L = "l", E))(I || {});
+const _ = 767, n = 264, o = 320;
+export {
+  o as DESKTOP_MENU_HEIGHT,
+  I as EMultiSelectSearchSize,
+  _ as MOBILE_BREAKPOINT,
+  n as MOBILE_MENU_HEIGHT
+};

package/dist/components/MultiSelectSearch/index.d.ts

@@ -0,0 +1,3 @@
+export { MultiSelectSearch } from './MultiSelectSearch';
+export type { TMultiSelectSearchProps, TMultiSelectOption } from './types';
+export { EMultiSelectSearchSize } from './constants';

package/dist/components/MultiSelectSearch/index.js

@@ -0,0 +1,6 @@
+import { MultiSelectSearch as t } from "./MultiSelectSearch.js";
+import { EMultiSelectSearchSize as c } from "./constants.js";
+export {
+  c as EMultiSelectSearchSize,
+  t as MultiSelectSearch
+};

package/dist/components/MultiSelectSearch/types.d.ts

@@ -0,0 +1,72 @@
+import { ReactNode } from 'react';
+import { EMultiSelectSearchSize } from './constants';
+import { EChipVariant } from '../Chip';
+import { TInputProps } from '../Input';
+
+export type TMultiSelectOption = {
+    name: string;
+    id: number | string;
+    bottom?: ReactNode;
+    [index: string]: unknown;
+};
+export type TMenuPlacement = 'top' | 'bottom';
+export type TMultiSelectSearchProps = Pick<TInputProps, 'withClearButton' | 'variant'> & {
+    /**
+     * Текущее выбранное значение.
+     */
+    value?: TMultiSelectOption[] | null;
+    /**
+     * Функция обратного вызова при изменении выбранного значения.
+     */
+    onChange?: (value: TMultiSelectOption[]) => void;
+    /**
+     * Текст-подсказка для поля, предназначенного для отображения выбранных значений.
+     */
+    placeholder?: string;
+    /**
+     * Размер компонента выбора.
+     */
+    size?: EMultiSelectSearchSize;
+    /**
+     * Флаг для растягивания компонента на всю ширину контейнера.
+     */
+    full?: boolean;
+    /**
+     * Значение, отображаемое в поле выбора.
+     */
+    displayValue?: string;
+    /** Показывать ли иконку стрелки выпадающего списка */
+    showArrow?: boolean;
+    /** Функция обратного вызова, срабатывающая при изменении поискового запроса */
+    onSearch?: (value: string) => void;
+    /** Фильтровать ли варианты на основе поискового запроса */
+    filterOnSearch?: boolean;
+    /** Значения, передаваемые в MultiSelectSearch */
+    items: TMultiSelectOption[];
+    /** Класснейм для значения */
+    classNameOption?: string;
+    /** Варианты отображения выпадающего меню */
+    menuPlacement?: TMenuPlacement;
+    /** Отключает компонент MultiSelectSearch */
+    disabled?: boolean;
+    /** Пропсы для инпута поиска опций */
+    searchProps?: Pick<TInputProps, 'numbersOnly' | 'maxLength' | 'required'>;
+    /** Отображать ли компонент Chip под MultiSelectSearch */
+    withChip?: boolean;
+    /** Вариант Chip*/
+    chipVariant?: EChipVariant | `${EChipVariant}`;
+    /** Отключает инпут, но позволяет открывать меню*/
+    disableInput?: boolean;
+    /** Управляет поведением автозаполнения браузера */
+    autocomplete?: 'on' | 'off';
+    /**
+     * Уникальный идентификатор мультиселекта
+     */
+    id?: string;
+    /**
+     * Автоматическое определение положения выпадающего меню
+     */
+    autoPlacement?: boolean;
+    /** Функция обратного вызова, срабатывающая при открытии и закрытии выпадающего списка */
+    onIsOpen?: (value: boolean) => void;
+};

package/dist/components/MultiSelectSearch/utils.d.ts

@@ -0,0 +1,11 @@
+import { EMultiSelectSearchSize } from './constants';
+import { TMultiSelectOption } from './types';
+import { EInputSize } from '../Input';
+
+export declare const mapSizeToInputSize: (size: EMultiSelectSearchSize) => EInputSize;
+export declare const getDropdownArrowIcon: (isOpen: boolean, size: EMultiSelectSearchSize) => "DropdownArrowBottom16px" | "DropdownArrowUp16px" | "DropdownArrowUp24px" | "DropdownArrowDown24px";
+export declare const getInitialInputValue: (value: TMultiSelectOption[] | undefined | null, displayValue: string) => string;
+export declare const joinSelectedItems: (items: TMultiSelectOption[], displayValue: string) => string;
+export declare const MULTISELECT_OPEN_EVENT = "multiselectOpen";
+export declare const dispatchMultiselectOpen: (id: string) => void;
+export declare const shouldShowMenuOnTop: (selectRef: React.RefObject<HTMLDivElement>, size: EMultiSelectSearchSize) => boolean;

package/dist/components/MultiSelectSearch/utils.js

@@ -0,0 +1,28 @@
+import { EMultiSelectSearchSize as o, MOBILE_MENU_HEIGHT as u, DESKTOP_MENU_HEIGHT as w } from "./constants.js";
+import "../../Input-DAmc_HxO.js";
+import { EInputSize as r } from "../Input/constants.js";
+const m = (t) => {
+  switch (t) {
+    case o.M:
+      return r.M;
+    case o.L:
+      return r.L;
+    default:
+      return r.M;
+  }
+}, M = (t, e) => t ? e === o.L ? "DropdownArrowUp24px" : "DropdownArrowUp16px" : e === o.L ? "DropdownArrowDown24px" : "DropdownArrowBottom16px", h = (t, e) => t && t.length > 0 ? t.map((n) => n[e]).join(", ") : "", I = (t, e) => t.map((n) => n[e]).join(", "), l = "multiselectOpen", S = (t) => {
+  window.dispatchEvent(new CustomEvent(l, { detail: t }));
+}, f = (t, e) => {
+  if (!t.current) return !1;
+  const n = t.current.getBoundingClientRect(), p = window.innerHeight, c = e === o.M ? u : w, i = p - n.bottom, s = n.top;
+  return i >= c ? !1 : s > i;
+};
+export {
+  l as MULTISELECT_OPEN_EVENT,
+  S as dispatchMultiselectOpen,
+  M as getDropdownArrowIcon,
+  h as getInitialInputValue,
+  I as joinSelectedItems,
+  m as mapSizeToInputSize,
+  f as shouldShowMenuOnTop
+};

package/dist/components/NotificationBadge/NotificationBadge.d.ts

@@ -0,0 +1,3 @@
+import { TNotificationBadgeProps } from './types';
+
+export declare const NotificationBadge: React.FC<TNotificationBadgeProps>;