nntc-ui 0.0.1

package/index.js

@@ -0,0 +1,2933 @@
+import {
+  AddIcon,
+  ArrowDropDownIcon,
+  ArrowDropUpIcon,
+  CheckboxDeselectedIcon,
+  CheckboxIcon,
+  CheckboxSeveralIcon,
+  ChevronLeftIcon,
+  ChevronRightIcon,
+  CloseIcon,
+  DateRangeIcon,
+  DoneIcon,
+  FilterIcon,
+  KeyboardArrowDownIcon,
+  SearchIcon,
+  SortDownIcon,
+  SortUpIcon
+} from "./chunk-RKPZOIBV.js";
+
+// src/components/common/Button/Button.tsx
+import classnames from "classnames";
+import { forwardRef } from "react";
+
+// src/components/common/Button/button.module.css
+var button_default = {
+  root: "button_root",
+  stateLayer: "button_stateLayer",
+  active: "button_active",
+  filled: "button_filled",
+  outlined: "button_outlined",
+  text: "button_text",
+  elevated: "button_elevated",
+  tonal: "button_tonal",
+  link: "button_link",
+  medium: "button_medium",
+  small: "button_small",
+  withIcon: "button_withIcon",
+  withoutIcon: "button_withoutIcon",
+  onlyIcon: "button_onlyIcon",
+  textSecondary: "button_textSecondary"
+};
+
+// src/components/common/Button/Button.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Button = forwardRef(function Button2({ variant = "filled", size = "medium", icon, textSecondary, isActive, className, children, classes, ...buttonProps }, propRef) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      className: classnames(
+        button_default.root,
+        button_default[variant],
+        button_default[size],
+        !icon ? button_default.withoutIcon : !children ? button_default.onlyIcon : button_default.withIcon,
+        isActive ? button_default.active : void 0,
+        textSecondary ? button_default.textSecondary : void 0,
+        className,
+        classes?.root
+      ),
+      ...buttonProps,
+      ref: propRef,
+      children: /* @__PURE__ */ jsxs("span", { className: classnames(button_default.stateLayer, classes?.stateLayer), children: [
+        icon,
+        children
+      ] })
+    }
+  );
+});
+
+// src/components/common/Checkbox/Checkbox.tsx
+import classnames3 from "classnames";
+import { useEffect, useRef } from "react";
+import { mergeRefs } from "react-merge-refs";
+import { v4 as uuidv4 } from "uuid";
+
+// src/components/view/Typography/Typography.tsx
+import classnames2 from "classnames";
+import { forwardRef as forwardRef2 } from "react";
+
+// src/components/view/Typography/typography.module.css
+var typography_default = {
+  h1: "typography_h1",
+  h2: "typography_h2",
+  h3: "typography_h3",
+  h4: "typography_h4",
+  h5: "typography_h5",
+  h6: "typography_h6",
+  h7: "typography_h7",
+  subtitle1: "typography_subtitle1",
+  subtitle2: "typography_subtitle2",
+  body1: "typography_body1",
+  body2: "typography_body2",
+  button: "typography_button",
+  caption: "typography_caption",
+  overline: "typography_overline"
+};
+
+// src/components/view/Typography/Typography.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Typography = forwardRef2(function Typography2({ variant = "body2", component, children, className, ...typographyProps }, propRef) {
+  const Component = component || "span";
+  return /* @__PURE__ */ jsx2(
+    Component,
+    {
+      className: classnames2(typography_default[variant], className),
+      ...typographyProps,
+      ref: propRef,
+      children
+    }
+  );
+});
+
+// src/hooks/useTranslation.ts
+import { useTranslation as useTranslationOriginal } from "react-i18next";
+var useTranslation = () => {
+  const { t, i18n } = useTranslationOriginal();
+  const changeLanguage = (language) => {
+    i18n.changeLanguage(language);
+  };
+  return {
+    t,
+    currentLanguage: i18n.language,
+    changeLanguage
+  };
+};
+
+// src/components/common/Checkbox/checkbox.module.css
+var checkbox_default = {
+  root: "checkbox_root",
+  input: "checkbox_input",
+  label: "checkbox_label",
+  checkbox: "checkbox_checkbox",
+  several: "checkbox_several",
+  deselected: "checkbox_deselected",
+  selected: "checkbox_selected",
+  labelText: "checkbox_labelText",
+  pressed: "checkbox_pressed"
+};
+
+// src/components/common/Checkbox/Checkbox.tsx
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function Checkbox(props) {
+  const { label, several, componentSize = "medium", classes, id, checked, ref, ...inputProps } = props;
+  const { t } = useTranslation();
+  const inputRef = useRef(null);
+  const inputId = id ?? uuidv4();
+  useEffect(() => {
+    const mouseupListener = function() {
+      this.classList.remove("pressed");
+    };
+    const mousedownListener = function() {
+      this.classList.add("pressed");
+    };
+    if (inputRef?.current) {
+      inputRef.current.addEventListener("mousedown", mousedownListener);
+      inputRef.current.addEventListener("mouseup", mouseupListener);
+    }
+    return () => {
+      if (inputRef?.current) {
+        inputRef.current.removeEventListener("mousedown", mousedownListener);
+        inputRef.current.removeEventListener("mouseup", mouseupListener);
+      }
+    };
+  }, [inputRef]);
+  return /* @__PURE__ */ jsxs2("div", { className: classnames3(checkbox_default.root, classes?.root), children: [
+    /* @__PURE__ */ jsx3(
+      "input",
+      {
+        ref: mergeRefs([inputRef, ref]),
+        type: "checkbox",
+        className: classnames3(checkbox_default.input, classes?.input),
+        placeholder: t("\u041F\u043E\u0438\u0441\u043A..."),
+        id: inputId,
+        title: label,
+        ...inputProps
+      }
+    ),
+    /* @__PURE__ */ jsxs2("label", { htmlFor: inputId, className: classnames3(checkbox_default.label, classes?.label), title: label, children: [
+      several ? /* @__PURE__ */ jsx3("span", { className: classnames3(checkbox_default.checkbox, checkbox_default.several, classes?.checkbox), children: /* @__PURE__ */ jsx3(CheckboxSeveralIcon, {}) }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+        /* @__PURE__ */ jsx3("span", { className: classnames3(checkbox_default.checkbox, checkbox_default.deselected, classes?.checkbox), children: /* @__PURE__ */ jsx3(CheckboxDeselectedIcon, {}) }),
+        /* @__PURE__ */ jsx3("span", { className: classnames3(checkbox_default.checkbox, checkbox_default.selected, classes?.checkbox), children: /* @__PURE__ */ jsx3(CheckboxIcon, {}) })
+      ] }),
+      !!label && /* @__PURE__ */ jsx3(Fragment, { children: componentSize === "large" ? /* @__PURE__ */ jsx3(Typography, { variant: "subtitle1", className: classnames3(checkbox_default.labelText, classes?.labelText), children: label }) : /* @__PURE__ */ jsx3(Typography, { variant: "subtitle2", className: classnames3(checkbox_default.labelText, classes?.labelText), children: label }) })
+    ] })
+  ] });
+}
+
+// src/components/common/Select/Select.tsx
+import classnames6 from "classnames";
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useState as useState3
+} from "react";
+import { mergeRefs as mergeRefs2 } from "react-merge-refs";
+import { v4 as uuidv42 } from "uuid";
+
+// src/components/view/Popover/Popover.tsx
+import classnames4 from "classnames";
+import { useState as useState2 } from "react";
+
+// src/components/view/Popover/popover.module.css
+var popover_default = {
+  trigger: "popover_trigger",
+  content: "popover_content"
+};
+
+// src/components/view/Popover/ui/PopoverContent/PopoverContent.tsx
+import { FloatingFocusManager, FloatingPortal, useId, useMergeRefs } from "@floating-ui/react";
+import { forwardRef as forwardRef3, useContext, useLayoutEffect } from "react";
+
+// src/components/view/Popover/ui/PopoverProvider/constants/PopoverContext.ts
+import { createContext } from "react";
+var PopoverContext = createContext(null);
+
+// src/components/view/Popover/ui/PopoverContent/PopoverContent.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var PopoverContent = forwardRef3(function PopoverContent2({ style, children, ...props }, propRef) {
+  const context = useContext(PopoverContext);
+  if (!context) {
+    return null;
+  }
+  const { context: floatingContext, ...otherContext } = context;
+  const ref = useMergeRefs([otherContext.refs.setFloating, propRef]);
+  const id = useId();
+  useLayoutEffect(() => {
+    context.setDescriptionId(id);
+    return () => context.setDescriptionId(void 0);
+  }, [id, context.setDescriptionId]);
+  if (!floatingContext.open)
+    return null;
+  return /* @__PURE__ */ jsx4(FloatingPortal, { children: /* @__PURE__ */ jsx4(FloatingFocusManager, { context: floatingContext, modal: otherContext.modal, children: /* @__PURE__ */ jsx4(
+    "div",
+    {
+      id,
+      ref,
+      style: { ...otherContext.floatingStyles, ...style },
+      "aria-describedby": otherContext.descriptionId,
+      ...otherContext.getFloatingProps(props),
+      children
+    }
+  ) }) });
+});
+
+// src/components/view/Popover/ui/PopoverProvider/hooks/usePopover.ts
+import {
+  autoUpdate,
+  flip,
+  offset,
+  shift,
+  useClick,
+  useDismiss,
+  useFloating,
+  useInteractions,
+  useRole
+} from "@floating-ui/react";
+import { useMemo, useState } from "react";
+function usePopover(props = {}) {
+  const {
+    initialOpen = false,
+    placement = "bottom",
+    modal,
+    open: controlledOpen,
+    onOpenChange: setControlledOpen,
+    containerOffset = 12
+  } = props;
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(initialOpen);
+  const [descriptionId, setDescriptionId] = useState();
+  const open = controlledOpen ?? uncontrolledOpen;
+  const setOpen = setControlledOpen ?? setUncontrolledOpen;
+  const data = useFloating({
+    placement,
+    open,
+    onOpenChange: setOpen,
+    whileElementsMounted: autoUpdate,
+    middleware: [
+      offset(containerOffset),
+      flip({
+        crossAxis: placement.includes("-"),
+        fallbackAxisSideDirection: "end",
+        padding: 5
+      }),
+      shift({ padding: 5 })
+    ]
+  });
+  const { context } = data;
+  const click = useClick(context, {
+    enabled: controlledOpen == void 0
+  });
+  const dismiss = useDismiss(context);
+  const role = useRole(context);
+  const interactions = useInteractions([click, dismiss, role]);
+  return useMemo(
+    () => ({
+      open,
+      setOpen,
+      ...interactions,
+      ...data,
+      modal,
+      descriptionId,
+      setDescriptionId
+    }),
+    [open, setOpen, interactions, data, modal, descriptionId]
+  );
+}
+
+// src/components/view/Popover/ui/PopoverProvider/PopoverProvider.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var PopoverProvider = (props) => {
+  const { children, modal = false, ...options } = props;
+  const popover = usePopover({ modal, ...options });
+  return /* @__PURE__ */ jsx5(PopoverContext.Provider, { value: popover, children });
+};
+
+// src/components/view/Popover/ui/PopoverTrigger/PopoverTrigger.tsx
+import { useMergeRefs as useMergeRefs2 } from "@floating-ui/react";
+import { cloneElement, forwardRef as forwardRef4, isValidElement, useContext as useContext2 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var PopoverTrigger = forwardRef4(
+  function PopoverTrigger2({ children, wrapTrigger = false, ...props }, propRef) {
+    const context = useContext2(PopoverContext);
+    const childrenRef = children.ref;
+    const ref = useMergeRefs2([context?.refs.setReference, propRef, childrenRef]);
+    if (!context) {
+      return null;
+    }
+    if (!wrapTrigger && isValidElement(children)) {
+      return cloneElement(
+        children,
+        context.getReferenceProps({
+          ref,
+          ...props,
+          ...children.props,
+          "data-state": context.open ? "open" : "closed"
+        })
+      );
+    }
+    return /* @__PURE__ */ jsx6("div", { ref, "data-state": context.open ? "open" : "closed", ...context.getReferenceProps(props), children });
+  }
+);
+
+// src/components/view/Popover/Popover.tsx
+import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+function Popover(props) {
+  const { description, clickable, initialOpen, placement, wrapTrigger, containerOffset, children, classes } = props;
+  const [showTooltip, setShowTooltip] = useState2(false);
+  if (!children) {
+    return null;
+  }
+  if (!description) {
+    return children;
+  }
+  return /* @__PURE__ */ jsxs3(
+    PopoverProvider,
+    {
+      placement,
+      initialOpen,
+      open: clickable ? showTooltip : void 0,
+      onOpenChange: clickable ? setShowTooltip : void 0,
+      containerOffset,
+      children: [
+        /* @__PURE__ */ jsx7(
+          PopoverTrigger,
+          {
+            wrapTrigger,
+            onClick: clickable ? () => setShowTooltip((prev) => !prev) : void 0,
+            className: classnames4(wrapTrigger ? popover_default.trigger : void 0, classes?.trigger),
+            children
+          }
+        ),
+        /* @__PURE__ */ jsx7(PopoverContent, { className: classnames4(popover_default.content, classes?.content), children: description })
+      ]
+    }
+  );
+}
+
+// src/components/view/Popover/ui/Arrow/Arrow.tsx
+import { useContext as useContext3 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function Arrow() {
+  const popoverContext = useContext3(PopoverContext);
+  return popoverContext?.open ? /* @__PURE__ */ jsx8(ArrowDropUpIcon, {}) : /* @__PURE__ */ jsx8(ArrowDropDownIcon, {});
+}
+
+// src/components/common/Select/select.module.css
+var select_default = {
+  root: "select_root",
+  medium: "select_medium",
+  small: "select_small",
+  label: "select_label",
+  wrapper: "select_wrapper",
+  input: "select_input",
+  withIcon: "select_withIcon",
+  withItemIcon: "select_withItemIcon",
+  icon: "select_icon",
+  itemIcon: "select_itemIcon",
+  filled: "select_filled",
+  outlined: "select_outlined",
+  arrow: "select_arrow",
+  popoverTarget: "select_popoverTarget",
+  popoverContent: "select_popoverContent"
+};
+
+// src/components/common/Select/ui/SelectPopover/SelectPopover.tsx
+import { useContext as useContext4 } from "react";
+
+// src/components/navigation/Menu/Menu.tsx
+import classnames5 from "classnames";
+import { useCallback } from "react";
+
+// src/components/navigation/Menu/menu.module.css
+var menu_default = {
+  root: "menu_root",
+  medium: "menu_medium",
+  small: "menu_small",
+  item: "menu_item",
+  stateLayer: "menu_stateLayer",
+  itemDisabled: "menu_itemDisabled",
+  itemSelected: "menu_itemSelected",
+  itemIcon: "menu_itemIcon",
+  itemTitle: "menu_itemTitle",
+  itemDescription: "menu_itemDescription",
+  divider: "menu_divider"
+};
+
+// src/components/navigation/Menu/Menu.tsx
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+function Menu(props) {
+  const { items, size = "medium", classes } = props;
+  const handleClick = useCallback(
+    (item) => (e) => {
+      item?.onClick?.();
+      e.currentTarget.blur();
+    },
+    []
+  );
+  return /* @__PURE__ */ jsx9("div", { className: classnames5(menu_default.root, menu_default[size], classes?.root), children: items.map(
+    (item, index) => item.type === "item" ? /* @__PURE__ */ jsx9(
+      "button",
+      {
+        tabIndex: -10,
+        className: classnames5(
+          menu_default.item,
+          item.selected ? menu_default.itemSelected : void 0,
+          item.disabled ? menu_default.itemDisabled : void 0,
+          classes?.item,
+          item.selected ? classes?.itemSelected : void 0,
+          item.disabled ? classes?.itemDisabled : void 0
+        ),
+        onClick: !item.disabled ? handleClick(item) : void 0,
+        title: item.name,
+        children: /* @__PURE__ */ jsxs4("span", { className: classnames5(menu_default.stateLayer), children: [
+          !!item.icon && /* @__PURE__ */ jsx9(
+            "span",
+            {
+              className: classnames5(
+                menu_default.itemIcon,
+                classes?.itemIcon,
+                item.selected ? classes?.itemSelectedIcon : void 0,
+                item.disabled ? classes?.itemDisabledIcon : void 0
+              ),
+              children: item.icon
+            }
+          ),
+          /* @__PURE__ */ jsx9(
+            "span",
+            {
+              className: classnames5(
+                menu_default.itemTitle,
+                classes?.itemTitle,
+                item.selected ? classes?.itemSelectedTitle : void 0,
+                item.disabled ? classes?.itemDisabledTitle : void 0
+              ),
+              children: item.name
+            }
+          ),
+          !!item.description && /* @__PURE__ */ jsx9(
+            "span",
+            {
+              className: classnames5(
+                menu_default.itemDescription,
+                classes?.itemDescription,
+                item.selected ? classes?.itemSelectedDescription : void 0,
+                item.disabled ? classes?.itemDisabledDescription : void 0
+              ),
+              children: item.description
+            }
+          )
+        ] })
+      },
+      `menu-item-${item.name}-${index}`
+    ) : /* @__PURE__ */ jsx9("div", { className: classnames5(menu_default.divider, classes?.divider), children: item.name }, `menu-divider-${item.name}-${index}`)
+  ) });
+}
+
+// src/components/common/Select/ui/SelectPopover/SelectPopover.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function SelectPopover(props) {
+  const { items, componentSize, selectedValue, changeSelectedItem, classes } = props;
+  const popoverContext = useContext4(PopoverContext);
+  return /* @__PURE__ */ jsx10(
+    Menu,
+    {
+      size: componentSize,
+      classes: classes?.menu,
+      items: items.map(
+        (i) => i.type === "divider" ? { type: "divider", name: i.name } : {
+          type: "item",
+          name: i.name,
+          icon: i.icon,
+          description: i.description,
+          disabled: i.disabled,
+          selected: i.value === selectedValue,
+          onClick: () => {
+            changeSelectedItem(i);
+            if (popoverContext) {
+              popoverContext.setOpen(false);
+            }
+          }
+        }
+      )
+    }
+  );
+}
+
+// src/components/common/Select/Select.tsx
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+function Select(props) {
+  const {
+    variant = "filled",
+    componentSize = "medium",
+    icon,
+    fullWidth,
+    label,
+    placeholder,
+    items,
+    defaultValue,
+    onValueChange,
+    selected,
+    classes,
+    ref,
+    disabled,
+    id,
+    ...inputProps
+  } = props;
+  const isLocalState = defaultValue && !selected;
+  const [localSelectedItem, setlocalSelectedItem] = useState3(
+    isLocalState ? items.find((i) => i.type === "item" && i.value === defaultValue) : void 0
+  );
+  const selectedItem = isLocalState ? localSelectedItem : selected;
+  const inputRef = useRef2(null);
+  const popoverTargetRef = useRef2(null);
+  const inputClickHandler = useCallback2(
+    (e) => {
+      e.preventDefault();
+      if (!disabled)
+        popoverTargetRef?.current?.click();
+    },
+    [popoverTargetRef]
+  );
+  const changeSelectedItem = (item) => {
+    if (isLocalState)
+      setlocalSelectedItem(item);
+    onValueChange?.(item);
+  };
+  useEffect2(() => {
+    if (selectedItem) {
+      const current = items.find((i) => i.type === "item" && i.value === selectedItem?.value);
+      if (!current)
+        changeSelectedItem(current);
+    }
+  }, [items, selectedItem]);
+  const inputId = id ?? uuidv42();
+  return /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      className: classnames6(select_default.root, select_default[componentSize], classes?.root),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        !!label && /* @__PURE__ */ jsx11(
+          Typography,
+          {
+            className: classnames6(select_default.label, classes?.label),
+            component: "label",
+            variant: "caption",
+            htmlFor: inputId,
+            onClick: inputClickHandler,
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            className: classnames6(
+              select_default.wrapper,
+              select_default[variant],
+              icon ? select_default.withIcon : void 0,
+              selectedItem?.icon ? select_default.withItemIcon : void 0,
+              classes?.wrapper
+            ),
+            children: [
+              /* @__PURE__ */ jsx11(
+                "input",
+                {
+                  ref: mergeRefs2([inputRef, ref]),
+                  id: inputId,
+                  className: classnames6(select_default.input, classes?.input),
+                  placeholder,
+                  ...inputProps,
+                  value: selectedItem?.name ?? "",
+                  onChange: () => {
+                  },
+                  onClick: inputClickHandler,
+                  disabled
+                }
+              ),
+              !!icon && /* @__PURE__ */ jsx11("span", { onClick: inputClickHandler, className: classnames6(select_default.icon, classes?.icon), children: icon }),
+              !!selectedItem?.icon && /* @__PURE__ */ jsx11("span", { onClick: inputClickHandler, className: classnames6(select_default.itemIcon, classes?.itemIcon), children: selectedItem?.icon }),
+              /* @__PURE__ */ jsx11("span", { onClick: inputClickHandler, className: classnames6(select_default.arrow, classes?.arrow), children: /* @__PURE__ */ jsx11(Arrow, {}) }),
+              /* @__PURE__ */ jsx11(
+                Popover,
+                {
+                  placement: "bottom-start",
+                  classes: {
+                    content: classnames6(select_default.popoverContent, "styledScroll", classes?.popoverContent),
+                    ...classes?.popover
+                  },
+                  containerOffset: 4,
+                  description: /* @__PURE__ */ jsx11(
+                    SelectPopover,
+                    {
+                      items,
+                      classes,
+                      componentSize,
+                      selectedValue: selectedItem?.value,
+                      changeSelectedItem
+                    }
+                  ),
+                  children: /* @__PURE__ */ jsx11("div", { ref: popoverTargetRef, className: classnames6(select_default.popoverTarget) })
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/common/DateTime/DateTime.tsx
+import classnames7 from "classnames";
+import dayjs2 from "dayjs";
+import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef3, useState as useState5 } from "react";
+import { mergeRefs as mergeRefs3 } from "react-merge-refs";
+
+// src/components/common/DateTime/dateTime.module.css
+var dateTime_default = {
+  root: "dateTime_root",
+  medium: "dateTime_medium",
+  small: "dateTime_small",
+  input: "dateTime_input",
+  filled: "dateTime_filled",
+  outlined: "dateTime_outlined",
+  icon: "dateTime_icon",
+  popoverTarget: "dateTime_popoverTarget"
+};
+
+// src/components/common/DateTime/ui/CalendarPopover/CalendarPopover.tsx
+import classNames from "classnames";
+import dayjs from "dayjs";
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo2, useState as useState4 } from "react";
+
+// src/components/common/DateTime/ui/CalendarPopover/calendarPopover.module.css
+var calendarPopover_default = {
+  root: "calendarPopover_root",
+  button: "calendarPopover_button",
+  navigationContainer: "calendarPopover_navigationContainer",
+  navigationArrow: "calendarPopover_navigationArrow",
+  navigationValue: "calendarPopover_navigationValue",
+  navigationTitle: "calendarPopover_navigationTitle",
+  cellsContainer: "calendarPopover_cellsContainer",
+  cell: "calendarPopover_cell",
+  month: "calendarPopover_month",
+  cellData: "calendarPopover_cellData",
+  cellCircle: "calendarPopover_cellCircle",
+  cellSelection: "calendarPopover_cellSelection",
+  cellSelectionFirst: "calendarPopover_cellSelectionFirst",
+  cellSelectionLast: "calendarPopover_cellSelectionLast",
+  monthCellSelection: "calendarPopover_monthCellSelection"
+};
+
+// src/components/common/DateTime/ui/CalendarPopover/CalendarPopover.tsx
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
+function CalendarPopover(props) {
+  const { componentSize, initStartDate, initEndDate, changeDates, onClear, classes } = props;
+  const [viewType, setViewType] = useState4("month");
+  const [currentItem, setCurrentItem] = useState4({
+    year: dayjs().year(),
+    month: dayjs().month()
+  });
+  const [startDate, setStartDate] = useState4(initStartDate ? dayjs(initStartDate).startOf("D").valueOf() : void 0);
+  const [endDate, setEndDate] = useState4(initEndDate ? dayjs(initEndDate).startOf("D").valueOf() : void 0);
+  const startDateMonth = useMemo2(() => startDate ? dayjs(startDate).startOf("M").valueOf() : void 0, [startDate]);
+  const endDateMonth = useMemo2(() => endDate ? dayjs(endDate).startOf("M").valueOf() : void 0, [endDate]);
+  const currentDate = useMemo2(
+    () => dayjs(new Date(currentItem.year, currentItem.month, 1)).startOf(viewType === "year" ? "y" : "M"),
+    [currentItem, viewType]
+  );
+  const daysInMonth = currentDate.daysInMonth();
+  const firstDayOfWeek = currentDate.startOf("M").day();
+  let emptyCellsCount = firstDayOfWeek - 1;
+  if (emptyCellsCount < 0) {
+    emptyCellsCount = 6;
+  }
+  useEffect3(() => {
+    if (!startDate && !endDate) {
+      onClear?.();
+      changeDates();
+    } else if (!!startDate && !!endDate) {
+      changeDates(dayjs(startDate).format(), dayjs(endDate).format());
+    }
+  }, [startDate, endDate]);
+  const changeCurrentItem = useCallback3(
+    (count) => () => {
+      const tempDate = dayjs(new Date(currentItem.year, currentItem.month, 1)).add(count, viewType);
+      setCurrentItem({
+        month: tempDate.month(),
+        year: tempDate.year()
+      });
+    },
+    [viewType, currentItem]
+  );
+  const changeViewType = useCallback3(
+    (date) => () => {
+      if (viewType === "year" && date) {
+        setCurrentItem({ month: date.month(), year: date.year() });
+        setViewType("month");
+      } else {
+        setViewType("year");
+      }
+    },
+    [viewType]
+  );
+  const setDate = useCallback3(
+    (cellDate) => () => {
+      if (startDate && endDate) {
+        if (cellDate === startDate) {
+          setStartDate(void 0);
+        } else if (cellDate === endDate) {
+          setEndDate(void 0);
+        } else {
+          setStartDate(cellDate);
+          setEndDate(void 0);
+        }
+      } else if (startDate) {
+        if (cellDate === startDate) {
+          setStartDate(void 0);
+        } else if (cellDate < startDate) {
+          setEndDate(startDate);
+          setStartDate(cellDate);
+        } else {
+          setEndDate(cellDate);
+        }
+      } else if (endDate) {
+        if (cellDate === endDate) {
+          setEndDate(void 0);
+        } else if (cellDate < endDate) {
+          setStartDate(cellDate);
+        } else {
+          setStartDate(endDate);
+          setEndDate(cellDate);
+        }
+      } else {
+        setStartDate(cellDate);
+      }
+    },
+    [startDate, endDate]
+  );
+  return /* @__PURE__ */ jsxs6("div", { className: classNames(calendarPopover_default.root, calendarPopover_default[componentSize], classes?.root), children: [
+    /* @__PURE__ */ jsxs6("div", { className: classNames(calendarPopover_default.navigationContainer, classes?.navigationContainer), children: [
+      /* @__PURE__ */ jsx12(
+        "button",
+        {
+          type: "button",
+          className: classNames(calendarPopover_default.button, calendarPopover_default.navigationArrow, classes?.navigationArrow),
+          onClick: changeCurrentItem(-1),
+          children: /* @__PURE__ */ jsx12(ChevronLeftIcon, {})
+        }
+      ),
+      /* @__PURE__ */ jsx12(
+        "button",
+        {
+          type: "button",
+          className: classNames(calendarPopover_default.button, calendarPopover_default.navigationValue, classes?.navigationValue),
+          onClick: changeViewType(),
+          children: /* @__PURE__ */ jsx12(Typography, { variant: "subtitle1", className: classNames(calendarPopover_default.navigationTitle, classes?.navigationTitle), children: viewType === "year" ? currentDate.format("YYYY") : currentDate.format("MMMM YYYY") })
+        }
+      ),
+      /* @__PURE__ */ jsx12(
+        "button",
+        {
+          type: "button",
+          className: classNames(calendarPopover_default.button, calendarPopover_default.navigationArrow, classes?.navigationArrow),
+          onClick: changeCurrentItem(1),
+          children: /* @__PURE__ */ jsx12(ChevronRightIcon, {})
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx12("div", { className: classNames(calendarPopover_default.cellsContainer, classes?.cellsContainer), children: viewType === "year" ? /* @__PURE__ */ jsx12(Fragment2, { children: [...Array(12)].map((__, index) => {
+      const cellDate = currentDate.add(index, "M");
+      const cellDateValue = cellDate.valueOf();
+      return /* @__PURE__ */ jsxs6(
+        "button",
+        {
+          type: "button",
+          className: classNames(calendarPopover_default.button, calendarPopover_default.cell, calendarPopover_default.month, classes?.cell, classes?.month),
+          onClick: changeViewType(cellDate),
+          children: [
+            startDateMonth !== void 0 && endDateMonth !== void 0 && cellDateValue >= startDateMonth && cellDateValue <= endDateMonth && /* @__PURE__ */ jsx12("span", { className: classNames(calendarPopover_default.monthCellSelection, classes?.monthCellSelection) }),
+            /* @__PURE__ */ jsx12(Typography, { variant: "subtitle1", className: classNames(calendarPopover_default.cellData, classes?.cellData), children: cellDate.format("MMMM") })
+          ]
+        },
+        `cell-${index}`
+      );
+    }) }) : /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      [...Array(emptyCellsCount)].map((__, index) => /* @__PURE__ */ jsx12("div", { className: classNames(calendarPopover_default.cell, classes?.cell) }, `empty-cell-${index}`)),
+      [...Array(daysInMonth)].map((__, index) => {
+        const cellDate = currentDate.add(index, "d").valueOf();
+        return /* @__PURE__ */ jsxs6(
+          "button",
+          {
+            type: "button",
+            className: classNames(calendarPopover_default.button, calendarPopover_default.cell, classes?.cell),
+            onClick: setDate(cellDate),
+            children: [
+              (cellDate === startDate || cellDate === endDate) && /* @__PURE__ */ jsx12("span", { className: classNames(calendarPopover_default.cellCircle, classes?.cellCircle) }),
+              startDate !== void 0 && endDate !== void 0 && cellDate >= startDate && cellDate <= endDate && /* @__PURE__ */ jsx12(
+                "span",
+                {
+                  className: classNames(
+                    calendarPopover_default.cellSelection,
+                    classes?.cellSelection,
+                    cellDate === startDate && calendarPopover_default.cellSelectionFirst,
+                    cellDate === startDate && classes?.cellSelectionFirst,
+                    cellDate === endDate && calendarPopover_default.cellSelectionLast,
+                    cellDate === endDate && classes?.cellSelectionLast
+                  )
+                }
+              ),
+              /* @__PURE__ */ jsx12(
+                Typography,
+                {
+                  variant: "subtitle1",
+                  className: classNames(calendarPopover_default.cellData, classes?.cellData),
+                  children: `${index + 1}`
+                }
+              )
+            ]
+          },
+          `cell-${index}`
+        );
+      })
+    ] }) })
+  ] });
+}
+
+// src/components/common/DateTime/DateTime.tsx
+import { jsx as jsx13, jsxs as jsxs7 } from "react/jsx-runtime";
+function DateTime(props) {
+  const {
+    variant = "filled",
+    componentSize = "medium",
+    fullWidth,
+    placeholder,
+    defaultValues,
+    values,
+    onClear,
+    onValueChange,
+    classes,
+    ref,
+    ...inputProps
+  } = props;
+  const [stateValues, setStateValues] = useState5(defaultValues);
+  useEffect4(() => {
+    setStateValues(values);
+  }, values);
+  const inputRef = useRef3(null);
+  const popoverTargetRef = useRef3(null);
+  const inputClickHandler = useCallback4(
+    (e) => {
+      e.preventDefault();
+      popoverTargetRef?.current?.click();
+    },
+    [popoverTargetRef]
+  );
+  const changeDates = (newStartDate, newEndDate) => {
+    setStateValues([newStartDate, newEndDate]);
+    onValueChange?.([newStartDate, newEndDate]);
+  };
+  return /* @__PURE__ */ jsxs7(
+    "div",
+    {
+      className: classnames7(
+        dateTime_default.root,
+        dateTime_default[variant],
+        dateTime_default[componentSize],
+        classes?.root
+      ),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        /* @__PURE__ */ jsx13(
+          "input",
+          {
+            ref: mergeRefs3([inputRef, ref]),
+            className: classnames7(dateTime_default.input, classes?.input),
+            placeholder,
+            ...inputProps,
+            value: !!stateValues?.[0] ? `${dayjs2(stateValues[0]).format("DD.MM.YYYY")}` + (stateValues[1] ? ` - ${dayjs2(stateValues[1]).format("DD.MM.YYYY")}` : "") : "",
+            onChange: () => {
+            },
+            onClick: inputClickHandler
+          }
+        ),
+        /* @__PURE__ */ jsx13("span", { onClick: inputClickHandler, className: classnames7(dateTime_default.icon, classes?.icon), children: /* @__PURE__ */ jsx13(DateRangeIcon, {}) }),
+        /* @__PURE__ */ jsx13(
+          Popover,
+          {
+            placement: "bottom-start",
+            classes: classes?.popover,
+            containerOffset: 4,
+            description: /* @__PURE__ */ jsx13(
+              CalendarPopover,
+              {
+                classes,
+                componentSize,
+                initStartDate: stateValues?.[0],
+                initEndDate: stateValues?.[1],
+                changeDates,
+                onClear
+              }
+            ),
+            children: /* @__PURE__ */ jsx13("div", { ref: popoverTargetRef, className: classnames7(dateTime_default.popoverTarget) })
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/common/ColorPicker/ColorPicker.tsx
+import classNames2 from "classnames";
+import { useCallback as useCallback5, useRef as useRef4, useState as useState6 } from "react";
+import { HexColorPicker } from "react-colorful";
+import { mergeRefs as mergeRefs4 } from "react-merge-refs";
+import { v4 as uuidv43 } from "uuid";
+
+// src/components/common/ColorPicker/colorPicker.module.css
+var colorPicker_default = {
+  root: "colorPicker_root",
+  medium: "colorPicker_medium",
+  small: "colorPicker_small",
+  label: "colorPicker_label",
+  wrapper: "colorPicker_wrapper",
+  input: "colorPicker_input",
+  icon: "colorPicker_icon",
+  outlined: "colorPicker_outlined",
+  arrow: "colorPicker_arrow",
+  popoverTarget: "colorPicker_popoverTarget",
+  popoverContent: "colorPicker_popoverContent"
+};
+
+// src/components/common/ColorPicker/ColorPicker.tsx
+import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
+var ColorPicker = (props) => {
+  const {
+    variant = "outlined",
+    componentSize = "medium",
+    fullWidth,
+    label,
+    classes,
+    placeholder,
+    ref,
+    disabled,
+    defaultValue,
+    id,
+    onValueChange,
+    ...inputProps
+  } = props;
+  const [color, setColor] = useState6(defaultValue?.toString() ?? "#AABBCC");
+  const inputRef = useRef4(null);
+  const popoverTargetRef = useRef4(null);
+  const changeColorHandler = useCallback5((newColor) => {
+    setColor(newColor.toUpperCase());
+    onValueChange?.(newColor.toUpperCase());
+  }, []);
+  const inputClickHandler = useCallback5(
+    (e) => {
+      e.preventDefault();
+      if (!disabled)
+        popoverTargetRef?.current?.click();
+    },
+    [popoverTargetRef]
+  );
+  const inputId = id ?? uuidv43();
+  return /* @__PURE__ */ jsxs8(
+    "div",
+    {
+      className: classNames2(colorPicker_default.root, colorPicker_default[componentSize], classes?.root),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        !!label && /* @__PURE__ */ jsx14(
+          Typography,
+          {
+            className: classNames2(colorPicker_default.label, classes?.label),
+            component: "label",
+            variant: "caption",
+            htmlFor: inputId,
+            onClick: inputClickHandler,
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsxs8("div", { className: classNames2(colorPicker_default.wrapper, colorPicker_default[variant], classes?.wrapper), children: [
+          /* @__PURE__ */ jsx14(
+            "input",
+            {
+              ref: mergeRefs4([inputRef, ref]),
+              id: inputId,
+              className: classNames2(colorPicker_default.input, classes?.input),
+              placeholder,
+              ...inputProps,
+              value: color,
+              onChange: () => {
+              },
+              onClick: inputClickHandler,
+              disabled
+            }
+          ),
+          /* @__PURE__ */ jsx14(
+            "span",
+            {
+              onClick: inputClickHandler,
+              className: classNames2(colorPicker_default.icon, classes?.icon),
+              style: { backgroundColor: color }
+            }
+          ),
+          /* @__PURE__ */ jsx14("span", { onClick: inputClickHandler, className: classNames2(colorPicker_default.arrow, classes?.arrow), children: /* @__PURE__ */ jsx14(Arrow, {}) }),
+          /* @__PURE__ */ jsx14(
+            Popover,
+            {
+              placement: "bottom-start",
+              classes: {
+                content: classNames2(colorPicker_default.popoverContent, "styledScroll", classes?.popoverContent),
+                ...classes?.popover
+              },
+              containerOffset: 4,
+              description: /* @__PURE__ */ jsx14(HexColorPicker, { color, onChange: changeColorHandler }),
+              children: /* @__PURE__ */ jsx14("div", { ref: popoverTargetRef, className: classNames2(colorPicker_default.popoverTarget) })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+
+// src/components/common/Input/Input.tsx
+import classnames8 from "classnames";
+import { useRef as useRef5 } from "react";
+import { mergeRefs as mergeRefs5 } from "react-merge-refs";
+import { v4 as uuidv44 } from "uuid";
+
+// src/components/common/Input/input.module.css
+var input_default = {
+  root: "input_root",
+  medium: "input_medium",
+  small: "input_small",
+  label: "input_label",
+  wrapper: "input_wrapper",
+  input: "input_input",
+  outlined: "input_outlined"
+};
+
+// src/components/common/Input/Input.tsx
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+var Input = (props) => {
+  const {
+    variant = "outlined",
+    componentSize = "medium",
+    fullWidth,
+    label,
+    classes,
+    placeholder,
+    ref,
+    id,
+    ...inputProps
+  } = props;
+  const inputRef = useRef5(null);
+  const inputId = id ?? uuidv44();
+  return /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      className: classnames8(input_default.root, input_default[componentSize], classes?.root),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        !!label && /* @__PURE__ */ jsx15(
+          Typography,
+          {
+            className: classnames8(input_default.label, classes?.label),
+            component: "label",
+            variant: "caption",
+            htmlFor: inputId,
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsx15("div", { className: classnames8(input_default.wrapper, input_default[variant], classes?.wrapper), children: /* @__PURE__ */ jsx15(
+          "input",
+          {
+            ref: mergeRefs5([inputRef, ref]),
+            id: inputId,
+            className: classnames8(input_default.input, classes?.input),
+            placeholder,
+            autoComplete: "off",
+            ...inputProps
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+// src/components/common/SearchInput/SearchInput.tsx
+import classnames9 from "classnames";
+import { useRef as useRef6 } from "react";
+import { mergeRefs as mergeRefs6 } from "react-merge-refs";
+
+// src/components/common/SearchInput/searchInput.module.css
+var searchInput_default = {
+  root: "searchInput_root",
+  medium: "searchInput_medium",
+  small: "searchInput_small",
+  input: "searchInput_input",
+  withIcon: "searchInput_withIcon",
+  icon: "searchInput_icon",
+  filled: "searchInput_filled",
+  outlined: "searchInput_outlined"
+};
+
+// src/components/common/SearchInput/SearchInput.tsx
+import { jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+function SearchInput(props) {
+  const {
+    variant = "filled",
+    componentSize = "medium",
+    disableIcon,
+    fullWidth,
+    placeholder,
+    classes,
+    ref,
+    ...inputProps
+  } = props;
+  const { t } = useTranslation();
+  const inputRef = useRef6(null);
+  return /* @__PURE__ */ jsxs10(
+    "div",
+    {
+      className: classnames9(
+        searchInput_default.root,
+        searchInput_default[variant],
+        searchInput_default[componentSize],
+        !disableIcon ? searchInput_default.withIcon : void 0,
+        classes?.root
+      ),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        !disableIcon && /* @__PURE__ */ jsx16(
+          "span",
+          {
+            className: classnames9(searchInput_default.icon, classes?.icon),
+            onClick: () => {
+              inputRef.current?.focus();
+            },
+            children: /* @__PURE__ */ jsx16(SearchIcon, {})
+          }
+        ),
+        /* @__PURE__ */ jsx16(
+          "input",
+          {
+            ref: mergeRefs6([inputRef, ref]),
+            className: classnames9(searchInput_default.input, classes?.input),
+            placeholder: placeholder ?? t("\u041F\u043E\u0438\u0441\u043A..."),
+            ...inputProps
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/common/WrapForLabel/WrapForLabel.tsx
+import classnames10 from "classnames";
+
+// src/components/common/WrapForLabel/wrapForLabel.module.css
+var wrapForLabel_default = {
+  root: "wrapForLabel_root",
+  medium: "wrapForLabel_medium",
+  small: "wrapForLabel_small"
+};
+
+// src/components/common/WrapForLabel/WrapForLabel.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+var WrapForLabel = (props) => {
+  const { componentSize = "medium", children, classes } = props;
+  return /* @__PURE__ */ jsx17("div", { className: classnames10(wrapForLabel_default.root, wrapForLabel_default[componentSize], classes?.root), children });
+};
+
+// src/components/common/MultiSelect/MultiSelect.tsx
+import classnames11 from "classnames";
+import { useCallback as useCallback6, useMemo as useMemo3, useRef as useRef7 } from "react";
+import { mergeRefs as mergeRefs7 } from "react-merge-refs";
+import { v4 as uuidv45 } from "uuid";
+
+// src/components/common/MultiSelect/multiSelect.module.css
+var multiSelect_default = {
+  root: "multiSelect_root",
+  medium: "multiSelect_medium",
+  small: "multiSelect_small",
+  label: "multiSelect_label",
+  wrapper: "multiSelect_wrapper",
+  input: "multiSelect_input",
+  withIcon: "multiSelect_withIcon",
+  withItemIcon: "multiSelect_withItemIcon",
+  icon: "multiSelect_icon",
+  itemIcon: "multiSelect_itemIcon",
+  filled: "multiSelect_filled",
+  outlined: "multiSelect_outlined",
+  clear: "multiSelect_clear",
+  arrow: "multiSelect_arrow",
+  popoverTarget: "multiSelect_popoverTarget",
+  popoverContent: "multiSelect_popoverContent"
+};
+
+// src/components/common/MultiSelect/ui/SelectPopover/SelectPopover.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+function SelectPopover2(props) {
+  const { items, componentSize, selected, changeSelectedItem, classes } = props;
+  return /* @__PURE__ */ jsx18(
+    Menu,
+    {
+      size: componentSize,
+      classes: classes?.menu,
+      items: items.map(
+        (i) => ({
+          type: "item",
+          name: i.name,
+          description: i.description,
+          disabled: i.disabled,
+          selected: selected?.includes(i.value),
+          onClick: () => {
+            changeSelectedItem(i);
+          }
+        })
+      )
+    }
+  );
+}
+
+// src/components/common/MultiSelect/utils/getTitle.ts
+var getTitle = (titleType, activeItems) => {
+  const { t } = useTranslation();
+  switch (titleType) {
+    case "allValue": {
+      return activeItems.map((i) => i.name).join(", ");
+    }
+    case "numberValue": {
+      return `${t("\u0412\u044B\u0431\u0440\u0430\u043D\u043E \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432")}: ` + activeItems.length;
+    }
+    case "firstValue": {
+      return `${activeItems[0]?.name} ${activeItems.length > 1 ? " +" + (activeItems.length - 1) : ""}`;
+    }
+  }
+};
+
+// src/components/common/MultiSelect/MultiSelect.tsx
+import { jsx as jsx19, jsxs as jsxs11 } from "react/jsx-runtime";
+function MultiSelect(props) {
+  const {
+    variant = "filled",
+    componentSize = "medium",
+    icon,
+    fullWidth,
+    label,
+    placeholder,
+    items,
+    onValueChange,
+    selected,
+    classes,
+    ref,
+    disabled,
+    id,
+    titleType = "allValue",
+    ...inputProps
+  } = props;
+  const inputRef = useRef7(null);
+  const popoverTargetRef = useRef7(null);
+  const activeItems = useMemo3(() => items.filter((i) => selected?.includes(i.value)), [selected, items]);
+  const inputClickHandler = useCallback6(
+    (e) => {
+      e.preventDefault();
+      if (!disabled)
+        popoverTargetRef?.current?.click();
+    },
+    [popoverTargetRef]
+  );
+  const changeSelectedItem = (item) => {
+    const newValue = selected ?? [];
+    if (newValue.includes(item.value)) {
+      onValueChange?.(newValue.filter((v) => v !== item.value));
+    } else {
+      onValueChange?.([...newValue, item.value]);
+    }
+  };
+  const title = useMemo3(() => {
+    if (!activeItems.length)
+      return "";
+    return getTitle(titleType, activeItems);
+  }, [titleType, activeItems.length]);
+  const clearHandler = () => {
+    onValueChange?.(null);
+  };
+  const inputId = id ?? uuidv45();
+  return /* @__PURE__ */ jsxs11(
+    "div",
+    {
+      className: classnames11(multiSelect_default.root, multiSelect_default[componentSize], classes?.root),
+      style: {
+        maxWidth: fullWidth ? "100%" : void 0
+      },
+      children: [
+        !!label && /* @__PURE__ */ jsx19(
+          Typography,
+          {
+            className: classnames11(multiSelect_default.label, classes?.label),
+            component: "label",
+            variant: "caption",
+            htmlFor: inputId,
+            onClick: inputClickHandler,
+            children: label
+          }
+        ),
+        /* @__PURE__ */ jsxs11(
+          "div",
+          {
+            className: classnames11(
+              multiSelect_default.wrapper,
+              multiSelect_default[variant],
+              icon ? multiSelect_default.withIcon : void 0,
+              classes?.wrapper
+            ),
+            children: [
+              /* @__PURE__ */ jsx19(
+                "input",
+                {
+                  ref: mergeRefs7([inputRef, ref]),
+                  id: inputId,
+                  className: classnames11(multiSelect_default.input, classes?.input),
+                  placeholder,
+                  ...inputProps,
+                  value: title,
+                  onClick: inputClickHandler,
+                  disabled,
+                  title: activeItems.map((i) => i.name).join(", ")
+                }
+              ),
+              !!icon && /* @__PURE__ */ jsx19("span", { onClick: inputClickHandler, className: classnames11(multiSelect_default.icon, classes?.icon), children: icon }),
+              !!activeItems.length && /* @__PURE__ */ jsx19("span", { onClick: clearHandler, className: classnames11(multiSelect_default.clear, classes?.clear), children: /* @__PURE__ */ jsx19(CloseIcon, {}) }),
+              /* @__PURE__ */ jsx19("span", { onClick: inputClickHandler, className: classnames11(multiSelect_default.arrow, classes?.arrow), children: /* @__PURE__ */ jsx19(Arrow, {}) }),
+              /* @__PURE__ */ jsx19(
+                Popover,
+                {
+                  placement: "bottom-start",
+                  classes: {
+                    content: classnames11(multiSelect_default.popoverContent, "styledScroll", classes?.popoverContent),
+                    ...classes?.popover
+                  },
+                  containerOffset: 4,
+                  description: /* @__PURE__ */ jsx19(
+                    SelectPopover2,
+                    {
+                      items,
+                      classes,
+                      componentSize,
+                      selected,
+                      changeSelectedItem
+                    }
+                  ),
+                  children: /* @__PURE__ */ jsx19("div", { ref: popoverTargetRef, className: classnames11(multiSelect_default.popoverTarget) })
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/common/Checklist/Checklist.tsx
+import classnames12 from "classnames";
+import { useState as useState7 } from "react";
+
+// src/components/common/Checklist/checklist.module.css
+var checklist_default = {
+  root: "checklist_root",
+  scrolled: "checklist_scrolled",
+  actionWrap: "checklist_actionWrap"
+};
+
+// src/components/common/Checklist/utils/filterItems.ts
+var filterItems = (items, filterText, selectedItems) => {
+  if (!filterText) {
+    return items.filter((item) => !selectedItems[item.value]);
+  }
+  const reduceCallback = (filteredItems, item) => {
+    if (item.name.toUpperCase().includes(filterText.toUpperCase()) && !selectedItems[item.value]) {
+      filteredItems.push({ ...item });
+    }
+    return filteredItems;
+  };
+  return items.reduce(reduceCallback, []);
+};
+
+// src/components/common/Checklist/Checklist.tsx
+import { Fragment as Fragment3, jsx as jsx20, jsxs as jsxs12 } from "react/jsx-runtime";
+function Checklist(props) {
+  const { items, selected, disableSearch, isDisabled, actionWithSelected, onChangeItem, classes } = props;
+  const { t } = useTranslation();
+  const [filterSubstring, setFilterSubstring] = useState7("");
+  const [selectedItems, setSelectedItems] = useState7(selected);
+  const filteredItems = filterItems(items, filterSubstring, selectedItems);
+  const handleClick = (item) => {
+    const value = !selected[item.value];
+    if (onChangeItem) {
+      onChangeItem?.(item);
+    }
+    const newSelected = { ...selected, [item.value]: value };
+    setSelectedItems(newSelected);
+    actionWithSelected(newSelected);
+  };
+  const onSelectAll = () => {
+    let newSelected = { ...selected };
+    filteredItems.forEach((item) => {
+      newSelected = { ...newSelected, [item.value]: true };
+    });
+    setSelectedItems(newSelected);
+    actionWithSelected(newSelected);
+  };
+  const onUnSelectAll = () => {
+    const newSelected = {};
+    setSelectedItems(newSelected);
+    actionWithSelected(newSelected);
+  };
+  return /* @__PURE__ */ jsxs12("div", { className: classnames12(checklist_default.root, classes?.root), children: [
+    !disableSearch && /* @__PURE__ */ jsx20(
+      SearchInput,
+      {
+        variant: "outlined",
+        disabled: isDisabled,
+        value: filterSubstring,
+        fullWidth: true,
+        classes: classes?.searchInput,
+        onChange: (e) => setFilterSubstring(e.target.value)
+      }
+    ),
+    /* @__PURE__ */ jsxs12("div", { className: classnames12(checklist_default.scrolled, "styledScroll"), children: [
+      items.some((item) => !!selectedItems[item.value]) && /* @__PURE__ */ jsxs12(Fragment3, { children: [
+        /* @__PURE__ */ jsxs12("div", { className: classnames12(checklist_default.actionWrap, classes?.actionWrap), children: [
+          /* @__PURE__ */ jsx20(Typography, { className: classnames12(classes?.typography), children: t("\u0412\u044B\u0431\u0440\u0430\u043D\u043D\u043E\u0435") }),
+          /* @__PURE__ */ jsx20(
+            Button,
+            {
+              variant: "link",
+              size: "small",
+              disabled: isDisabled,
+              onClick: onUnSelectAll,
+              className: classnames12(classes?.button),
+              children: t("\u041E\u0442\u043C\u0435\u043D\u0438\u0442\u044C")
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx20("div", { children: items.filter((item) => !!selectedItems[item.value]).map((item) => /* @__PURE__ */ jsx20(
+          Checkbox,
+          {
+            label: item.name,
+            defaultChecked: !!selected[item.value],
+            onClick: (e) => {
+              e.stopPropagation();
+              handleClick(item);
+            },
+            disabled: isDisabled,
+            classes: classes?.checkbox
+          },
+          `selected-${item.value}`
+        )) })
+      ] }),
+      !isDisabled && !!filteredItems.length && /* @__PURE__ */ jsx20(
+        Button,
+        {
+          variant: "link",
+          size: "small",
+          disabled: isDisabled,
+          onClick: onSelectAll,
+          className: classnames12(classes?.button),
+          children: t("\u0412\u044B\u0431\u0440\u0430\u0442\u044C \u0432\u0441\u0435")
+        }
+      ),
+      /* @__PURE__ */ jsx20("div", { children: filteredItems.map((item) => /* @__PURE__ */ jsx20(
+        Checkbox,
+        {
+          label: item.name,
+          defaultChecked: !!selected[item.value],
+          onClick: (e) => {
+            e.stopPropagation();
+            handleClick(item);
+          },
+          disabled: isDisabled,
+          classes: classes?.checkbox
+        },
+        `filtered-${item.value}`
+      )) })
+    ] })
+  ] });
+}
+
+// src/components/common/ButtonsGroup/ButtonsGroup.tsx
+import classNames3 from "classnames";
+
+// src/components/common/ButtonsGroup/buttonsGroup.module.css
+var buttonsGroup_default = {
+  root: "buttonsGroup_root"
+};
+
+// src/components/common/ButtonsGroup/ButtonsGroup.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
+var ButtonsGroup = (props) => {
+  const { children, classes } = props;
+  return /* @__PURE__ */ jsx21("div", { className: classNames3(buttonsGroup_default.root, classes?.root), children });
+};
+
+// src/components/layout/Surface/Surface.tsx
+import classnames13 from "classnames";
+
+// src/components/layout/Surface/surface.module.css
+var surface_default = {
+  root: "surface_root",
+  primary: "surface_primary",
+  panel: "surface_panel",
+  modal: "surface_modal"
+};
+
+// src/components/layout/Surface/Surface.tsx
+import { jsx as jsx22 } from "react/jsx-runtime";
+function Surface(props) {
+  const { type = "primary", children, classes } = props;
+  return /* @__PURE__ */ jsx22("div", { className: classnames13(surface_default.root, classes?.root, surface_default[type]), children });
+}
+
+// src/components/layout/Layout/Layout.tsx
+import classnames14 from "classnames";
+
+// src/components/layout/Layout/layout.module.css
+var layout_default = {
+  root: "layout_root",
+  withHeader: "layout_withHeader"
+};
+
+// src/components/layout/Layout/Layout.tsx
+import { jsx as jsx23 } from "react/jsx-runtime";
+function Layout(props) {
+  const { withoutHeader, children, classes } = props;
+  return /* @__PURE__ */ jsx23("div", { className: classnames14(layout_default.root, !withoutHeader ? layout_default.withHeader : void 0, classes?.root), children });
+}
+
+// src/components/navigation/Tabs/Tabs.tsx
+import classnames15 from "classnames";
+import { useEffect as useEffect5, useState as useState8 } from "react";
+
+// src/components/navigation/Tabs/tabs.module.css
+var tabs_default = {
+  root: "tabs_root",
+  tab: "tabs_tab",
+  tabTitle: "tabs_tabTitle",
+  tabBorder: "tabs_tabBorder",
+  selected: "tabs_selected"
+};
+
+// src/components/navigation/Tabs/Tabs.tsx
+import { jsx as jsx24, jsxs as jsxs13 } from "react/jsx-runtime";
+function Tabs(props) {
+  const { items, defaultSelected, onChange, classes } = props;
+  const [isMounted, setIsMounted] = useState8(false);
+  const [selectedTab, setSelectedTab] = useState8(defaultSelected);
+  const handleClick = (newValue) => () => {
+    setSelectedTab(newValue);
+  };
+  useEffect5(() => {
+    if (isMounted && !!selectedTab) {
+      onChange?.(selectedTab);
+    }
+    if (!isMounted) {
+      setIsMounted(true);
+    }
+  }, [selectedTab]);
+  return /* @__PURE__ */ jsx24("div", { className: classnames15(tabs_default.root, classes?.root), children: items.map((item) => /* @__PURE__ */ jsxs13(
+    "div",
+    {
+      className: classnames15(
+        tabs_default.tab,
+        selectedTab === item.value ? tabs_default.selected : void 0,
+        classes?.tab,
+        selectedTab === item.value ? classes?.tabSelected : void 0
+      ),
+      onClick: handleClick(item.value),
+      children: [
+        /* @__PURE__ */ jsx24(
+          "div",
+          {
+            className: classnames15(
+              tabs_default.tabTitle,
+              classes?.tabTitle,
+              selectedTab === item.value ? classes?.tabSelectedTitle : void 0
+            ),
+            children: /* @__PURE__ */ jsx24("span", { title: item.name, children: item.name })
+          }
+        ),
+        /* @__PURE__ */ jsx24(
+          "div",
+          {
+            className: classnames15(
+              tabs_default.tabBorder,
+              classes?.tabBorder,
+              selectedTab === item.value ? classes?.tabSelectedBorder : void 0
+            )
+          }
+        )
+      ]
+    },
+    `tab-${item.value}`
+  )) });
+}
+
+// src/components/view/VirtualTable/VirtualTable.tsx
+import { flexRender, getCoreRowModel, useReactTable } from "@tanstack/react-table";
+import { useVirtualizer } from "@tanstack/react-virtual";
+import classnames21 from "classnames";
+import { Fragment as Fragment6, useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo7, useRef as useRef10, useState as useState13 } from "react";
+
+// src/components/view/Tooltip/Tooltip.tsx
+import classnames17 from "classnames";
+import { useRef as useRef8, useState as useState10 } from "react";
+
+// src/components/view/Tooltip/tooltip.module.css
+var tooltip_default = {
+  trigger: "tooltip_trigger",
+  content: "tooltip_content",
+  success: "tooltip_success",
+  warning: "tooltip_warning",
+  error: "tooltip_error",
+  info: "tooltip_info",
+  arrow: "tooltip_arrow",
+  "top-arrow": "tooltip_top-arrow",
+  "bottom-arrow": "tooltip_bottom-arrow",
+  "left-arrow": "tooltip_left-arrow",
+  "right-arrow": "tooltip_right-arrow"
+};
+
+// src/components/view/Tooltip/ui/TooltipContent/TooltipContent.tsx
+import { FloatingPortal as FloatingPortal2, useMergeRefs as useMergeRefs3 } from "@floating-ui/react";
+import classnames16 from "classnames";
+import { forwardRef as forwardRef5, useContext as useContext5 } from "react";
+
+// src/components/view/Tooltip/ui/TooltipProvider/constants/TooltipContext.ts
+import { createContext as createContext2 } from "react";
+var TooltipContext = createContext2(null);
+
+// src/components/view/Tooltip/ui/TooltipContent/TooltipContent.tsx
+import { jsx as jsx25, jsxs as jsxs14 } from "react/jsx-runtime";
+var TooltipContent = forwardRef5(function TooltipContent2({ style, children, ...props }, propRef) {
+  const context = useContext5(TooltipContext);
+  if (!context) {
+    return null;
+  }
+  const ref = useMergeRefs3([context.refs.setFloating, propRef]);
+  if (!context.open)
+    return null;
+  let arrowClassName = "";
+  let invertX = null;
+  let invertY = null;
+  switch (context.placement) {
+    case "top":
+    case "top-end":
+    case "top-start":
+      arrowClassName = "top-arrow";
+      invertY = false;
+      break;
+    case "bottom":
+    case "bottom-end":
+    case "bottom-start":
+      arrowClassName = "bottom-arrow";
+      invertY = true;
+      break;
+    case "left":
+    case "left-end":
+    case "left-start":
+      arrowClassName = "left-arrow";
+      invertX = true;
+      break;
+    case "right":
+    case "right-end":
+    case "right-start":
+      arrowClassName = "right-arrow";
+      invertX = false;
+      break;
+    default:
+      break;
+  }
+  return /* @__PURE__ */ jsx25(FloatingPortal2, { children: /* @__PURE__ */ jsxs14(
+    "div",
+    {
+      ref,
+      style: {
+        ...context.floatingStyles,
+        ...style
+      },
+      ...context.getFloatingProps(props),
+      children: [
+        children,
+        !context.withoutArrow && /* @__PURE__ */ jsx25(
+          "div",
+          {
+            className: classnames16("arrow", arrowClassName),
+            ref: context.arrowRef,
+            style: {
+              position: "absolute",
+              left: invertY === null && invertX === false ? 0 : context.middlewareData.arrow?.x,
+              right: invertY === null && invertX === true ? 0 : context.middlewareData.arrow?.x,
+              top: invertX === null && invertY === true ? 0 : context.middlewareData.arrow?.y,
+              bottom: invertX === null && invertY === false ? 0 : context.middlewareData.arrow?.y
+            }
+          }
+        )
+      ]
+    }
+  ) });
+});
+
+// src/components/view/Tooltip/ui/TooltipProvider/hooks/useTooltip.ts
+import {
+  arrow,
+  autoUpdate as autoUpdate2,
+  flip as flip2,
+  offset as offset2,
+  shift as shift2,
+  useDismiss as useDismiss2,
+  useFloating as useFloating2,
+  useFocus,
+  useHover,
+  useInteractions as useInteractions2,
+  useRole as useRole2
+} from "@floating-ui/react";
+import { useMemo as useMemo4, useState as useState9 } from "react";
+function useTooltip(props = {}) {
+  const {
+    initialOpen = false,
+    placement = "top",
+    open: controlledOpen,
+    onOpenChange: setControlledOpen,
+    withoutArrow,
+    arrowRef
+  } = props;
+  const [uncontrolledOpen, setUncontrolledOpen] = useState9(initialOpen);
+  const open = controlledOpen ?? uncontrolledOpen;
+  const setOpen = setControlledOpen ?? setUncontrolledOpen;
+  const data = useFloating2({
+    placement,
+    open,
+    onOpenChange: setOpen,
+    whileElementsMounted: autoUpdate2,
+    middleware: [
+      offset2(12),
+      flip2({
+        crossAxis: placement.includes("-"),
+        fallbackAxisSideDirection: "start",
+        padding: 5
+      }),
+      shift2({ padding: 5 }),
+      ...!withoutArrow && arrowRef?.current ? [arrow({ element: arrowRef })] : []
+    ]
+  });
+  const { context } = data;
+  const hover = useHover(context, {
+    move: false,
+    enabled: controlledOpen == null
+  });
+  const focus = useFocus(context, {
+    enabled: controlledOpen == null
+  });
+  const dismiss = useDismiss2(context);
+  const role = useRole2(context, { role: "tooltip" });
+  const interactions = useInteractions2([hover, focus, dismiss, role]);
+  return useMemo4(
+    () => ({
+      open,
+      setOpen,
+      withoutArrow,
+      arrowRef,
+      ...interactions,
+      ...data
+    }),
+    [open, setOpen, interactions, data]
+  );
+}
+
+// src/components/view/Tooltip/ui/TooltipProvider/TooltipProvider.tsx
+import { jsx as jsx26 } from "react/jsx-runtime";
+var TooltipProvider = (props) => {
+  const { children, ...options } = props;
+  const tooltip = useTooltip(options);
+  return /* @__PURE__ */ jsx26(TooltipContext.Provider, { value: tooltip, children });
+};
+
+// src/components/view/Tooltip/ui/TooltipTrigger/TooltipTrigger.tsx
+import { useMergeRefs as useMergeRefs4 } from "@floating-ui/react";
+import { cloneElement as cloneElement2, forwardRef as forwardRef6, isValidElement as isValidElement2, useContext as useContext6 } from "react";
+import { jsx as jsx27 } from "react/jsx-runtime";
+var TooltipTrigger = forwardRef6(
+  function TooltipTrigger2({ children, wrapTrigger = false, ...props }, propRef) {
+    const context = useContext6(TooltipContext);
+    const childrenRef = children.ref;
+    const ref = useMergeRefs4([context?.refs.setReference, propRef, childrenRef]);
+    if (!context) {
+      return null;
+    }
+    if (!wrapTrigger && isValidElement2(children)) {
+      return cloneElement2(
+        children,
+        context.getReferenceProps({
+          ref,
+          ...props,
+          ...children.props,
+          "data-state": context.open ? "open" : "closed"
+        })
+      );
+    }
+    return /* @__PURE__ */ jsx27("div", { ref, "data-state": context.open ? "open" : "closed", ...context.getReferenceProps(props), children });
+  }
+);
+
+// src/components/view/Tooltip/Tooltip.tsx
+import { jsx as jsx28, jsxs as jsxs15 } from "react/jsx-runtime";
+function Tooltip(props) {
+  const {
+    label,
+    clickable,
+    initialOpen,
+    placement,
+    withoutArrow,
+    wrapTrigger,
+    alertType = "default",
+    children,
+    classes
+  } = props;
+  const [showTooltip, setShowTooltip] = useState10(false);
+  const arrowRef = useRef8(null);
+  if (!label) {
+    return children;
+  }
+  if (!children) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs15(
+    TooltipProvider,
+    {
+      placement,
+      initialOpen,
+      open: clickable ? showTooltip : void 0,
+      onOpenChange: clickable ? setShowTooltip : void 0,
+      withoutArrow,
+      arrowRef,
+      children: [
+        /* @__PURE__ */ jsx28(
+          TooltipTrigger,
+          {
+            wrapTrigger,
+            onClick: clickable ? () => setShowTooltip((prev) => !prev) : void 0,
+            className: wrapTrigger ? classnames17(tooltip_default.trigger, classes?.trigger) : void 0,
+            children
+          }
+        ),
+        /* @__PURE__ */ jsx28(
+          TooltipContent,
+          {
+            className: classnames17(tooltip_default.content, tooltip_default[alertType], classes?.content),
+            children: label
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/hooks/window/hooks/useWindowSize.ts
+import { useLayoutEffect as useLayoutEffect2, useState as useState11 } from "react";
+var useWindowSize = () => {
+  const [size, setSize] = useState11([0, 0]);
+  useLayoutEffect2(() => {
+    function updateSize() {
+      setSize([window.innerWidth, window.innerHeight]);
+    }
+    window.addEventListener("resize", updateSize);
+    updateSize();
+    return () => window.removeEventListener("resize", updateSize);
+  }, []);
+  return size;
+};
+
+// src/components/view/VirtualTable/constants/defaultRowHeight.ts
+var defaultRowHeight = 32;
+
+// src/components/view/VirtualTable/ui/DefaultColumn/DefaultColumn.tsx
+import classnames19 from "classnames";
+import { useEffect as useEffect7, useMemo as useMemo5, useState as useState12 } from "react";
+import { createPortal } from "react-dom";
+
+// src/components/view/Modal/Modal.tsx
+import classnames18 from "classnames";
+import { useEffect as useEffect6, useRef as useRef9 } from "react";
+
+// src/components/view/Modal/modal.module.css
+var modal_default = {
+  root: "modal_root",
+  modal: "modal_modal"
+};
+
+// src/components/view/Modal/Modal.tsx
+import { jsx as jsx29 } from "react/jsx-runtime";
+function Modal(props) {
+  const { close, children, classes } = props;
+  const rootRef = useRef9(null);
+  useEffect6(() => {
+    const clickListener = function(e) {
+      if (e.target === rootRef?.current) {
+        close();
+      }
+    };
+    if (rootRef?.current) {
+      rootRef.current.addEventListener("click", clickListener);
+    }
+    return () => {
+      if (rootRef?.current) {
+        rootRef.current.removeEventListener("click", clickListener);
+      }
+    };
+  }, [rootRef]);
+  return /* @__PURE__ */ jsx29("div", { ref: rootRef, className: classnames18(modal_default.root, classes?.root), children: /* @__PURE__ */ jsx29("div", { className: classnames18(modal_default.modal, classes?.modal), children }) });
+}
+
+// src/components/view/VirtualTable/virtualTable.module.css
+var virtualTable_default = {
+  root: "virtualTable_root",
+  tableContainer: "virtualTable_tableContainer",
+  table: "virtualTable_table",
+  th: "virtualTable_th",
+  firstThRow: "virtualTable_firstThRow",
+  thCell: "virtualTable_thCell",
+  label: "virtualTable_label",
+  alignLeft: "virtualTable_alignLeft",
+  alignRight: "virtualTable_alignRight",
+  alignCenter: "virtualTable_alignCenter",
+  td: "virtualTable_td",
+  evenRow: "virtualTable_evenRow",
+  selected: "virtualTable_selected",
+  marginLeftChanging: "virtualTable_marginLeftChanging",
+  marginLeftChangingLast: "virtualTable_marginLeftChangingLast",
+  marginTopChanging: "virtualTable_marginTopChanging",
+  rightBorder: "virtualTable_rightBorder",
+  bottomBorder: "virtualTable_bottomBorder",
+  viewCell: "virtualTable_viewCell",
+  error: "virtualTable_error",
+  viewSpan: "virtualTable_viewSpan",
+  showInModal: "virtualTable_showInModal",
+  modalContent: "virtualTable_modalContent",
+  verticalAlignFlexStart: "virtualTable_verticalAlignFlexStart",
+  verticalAlignCenter: "virtualTable_verticalAlignCenter",
+  verticalAlignFlexEnd: "virtualTable_verticalAlignFlexEnd"
+};
+
+// src/components/view/VirtualTable/ui/DefaultColumn/DefaultColumn.tsx
+import { Fragment as Fragment4, jsx as jsx30, jsxs as jsxs16 } from "react/jsx-runtime";
+var DefaultColumn = {
+  cell: ({ getValue, row: { index, original }, column: { id, columnDef }, table }) => {
+    const initialValue = getValue();
+    const { meta } = columnDef;
+    const tableMeta = table.options.meta;
+    const [value, setValue] = useState12(initialValue);
+    const [isEdit, setIsEdit] = useState12(false);
+    const [showModal, setShowModal] = useState12(false);
+    useEffect7(() => {
+      setValue(initialValue);
+    }, [initialValue]);
+    const modalPortal = useMemo5(() => document.getElementById("modal-portal"), []);
+    const additionalViewResult = tableMeta?.additionalColumnsViews?.(id, initialValue);
+    if (isEdit && meta?.editable) {
+      const onBlur = () => {
+        tableMeta?.updateData(index, id, value, original);
+        setIsEdit(false);
+      };
+      const onChange = (e) => {
+        setValue(e.target.value);
+      };
+      return /* @__PURE__ */ jsx30(Tooltip, { label: original[id]?.error ?? "", alertType: "error", children: additionalViewResult?.edit !== null && additionalViewResult?.edit !== void 0 ? additionalViewResult.edit(onChange, onBlur) : /* @__PURE__ */ jsx30(Fragment4, { children: /* @__PURE__ */ jsx30("input", { onChange, onBlur, value: value ?? "", autoFocus: true }) }) });
+    }
+    const shownValue = additionalViewResult?.view !== null && additionalViewResult?.view !== void 0 ? additionalViewResult.view : meta?.valueFormat ? meta.valueFormat(initialValue?.toString() ?? "") : meta?.toFixed && !Number.isNaN(parseFloat(initialValue)) ? parseFloat(Number(initialValue).toFixed(meta.toFixed)) : initialValue;
+    return /* @__PURE__ */ jsx30(Tooltip, { label: original[id]?.error, alertType: "error", children: /* @__PURE__ */ jsxs16(
+      "div",
+      {
+        className: classnames19(
+          virtualTable_default.viewCell,
+          !!meta?.rowsAlign ? virtualTable_default[`align${meta?.rowsAlign}`] : void 0,
+          meta?.showInModal ? virtualTable_default.showInModal : void 0,
+          original[id]?.error ? virtualTable_default.error : void 0,
+          !!meta?.verticalAlign ? virtualTable_default[`verticalAlign${meta?.verticalAlign}`] : void 0
+        ),
+        onClick: meta?.editable ? () => {
+          setIsEdit(true);
+        } : meta?.showInModal ? () => {
+          setShowModal(true);
+        } : void 0,
+        children: [
+          /* @__PURE__ */ jsx30("span", { className: virtualTable_default.viewSpan, children: shownValue }),
+          showModal && modalPortal && createPortal(
+            /* @__PURE__ */ jsx30(Modal, { close: () => setShowModal(false), children: /* @__PURE__ */ jsx30(Surface, { type: "panel", children: /* @__PURE__ */ jsx30("div", { className: virtualTable_default.modalContent, children: shownValue }) }) }),
+            modalPortal
+          )
+        ]
+      }
+    ) });
+  }
+};
+
+// src/components/view/VirtualTable/ui/HeaderDropdown/HeaderDropdown.tsx
+import classnames20 from "classnames";
+import { useMemo as useMemo6 } from "react";
+
+// src/components/view/VirtualTable/ui/HeaderDropdown/headerDropdown.module.css
+var headerDropdown_default = {
+  root: "headerDropdown_root",
+  checklistWrap: "headerDropdown_checklistWrap",
+  iconButton: "headerDropdown_iconButton"
+};
+
+// src/components/view/VirtualTable/ui/HeaderDropdown/HeaderDropdown.tsx
+import { Fragment as Fragment5, jsx as jsx31, jsxs as jsxs17 } from "react/jsx-runtime";
+function HeaderDropdown(props) {
+  const {
+    sortable,
+    sortBy,
+    setSortBy,
+    sortAnotherName,
+    filterable,
+    filterBy,
+    setFilterBy,
+    headerName,
+    items,
+    children
+  } = props;
+  const headerResultName = sortAnotherName ?? headerName;
+  const filterItems2 = useMemo6(() => {
+    const checklistItems = items.filter((i) => Object.keys(i).includes(headerResultName)).map(
+      (i) => ({
+        name: i[headerResultName].value,
+        value: i[headerResultName].value
+      })
+    );
+    const uniqueChecklistItems = [
+      ...checklistItems.reduce((a, c) => {
+        a.set(c.value, c);
+        return a;
+      }, /* @__PURE__ */ new Map()).values()
+    ];
+    return uniqueChecklistItems;
+  }, [items, headerResultName]);
+  const filterSelectedItems = useMemo6(() => {
+    const result = {};
+    filterBy.find((fb) => fb.columnName === headerResultName)?.values.forEach((v) => {
+      result[v] = true;
+    });
+    return result;
+  }, [filterBy, headerResultName]);
+  const handleSortClick = (direction) => () => {
+    setSortBy((prev) => {
+      if (prev.some((p) => p.columnName === headerResultName && p.direction === direction)) {
+        return prev.filter((p) => !(p.columnName === headerResultName && p.direction === direction));
+      } else {
+        if (prev.some((p) => p.columnName === headerResultName)) {
+          return prev.map((p) => p.columnName === headerResultName ? { ...p, direction } : { ...p });
+        } else {
+          return prev.concat([{ columnName: headerResultName, direction }]);
+        }
+      }
+    });
+  };
+  const actionWithSelectedObjects = (selected) => {
+    Object.entries(selected).forEach(([key, value]) => {
+      if (!value) {
+        delete selected[key];
+      }
+    });
+    setFilterBy((prev) => {
+      const newResult = [...prev];
+      const exist = newResult.find((p) => p.columnName === headerResultName);
+      if (exist) {
+        exist.values = Object.keys(selected);
+      } else {
+        newResult.push({ columnName: headerResultName, values: Object.keys(selected) });
+      }
+      return newResult;
+    });
+  };
+  const hasAnyFilter = Object.keys(filterSelectedItems).length || sortBy.some((sb) => sb.columnName === headerResultName);
+  const { t } = useTranslation();
+  return /* @__PURE__ */ jsxs17("div", { className: classnames20(headerDropdown_default.root), children: [
+    children,
+    /* @__PURE__ */ jsx31(
+      Popover,
+      {
+        placement: "bottom-end",
+        wrapTrigger: true,
+        description: /* @__PURE__ */ jsxs17(Fragment5, { children: [
+          filterable && /* @__PURE__ */ jsx31("div", { className: classnames20(headerDropdown_default.checklistWrap), children: /* @__PURE__ */ jsx31(
+            Checklist,
+            {
+              items: filterItems2,
+              selected: filterSelectedItems,
+              actionWithSelected: actionWithSelectedObjects
+            }
+          ) }),
+          sortable && /* @__PURE__ */ jsx31("div", { children: /* @__PURE__ */ jsx31(
+            Menu,
+            {
+              items: [
+                {
+                  type: "divider",
+                  name: t("\u0421\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u043A\u0430")
+                },
+                {
+                  type: "item",
+                  name: t("\u041F\u043E \u0432\u043E\u0437\u0440\u0430\u0441\u0442\u0430\u043D\u0438\u044E"),
+                  icon: /* @__PURE__ */ jsx31(SortUpIcon, {}),
+                  selected: sortBy.some((sb) => sb.columnName === headerResultName && sb.direction === "asc"),
+                  onClick: handleSortClick("asc")
+                },
+                {
+                  type: "item",
+                  name: t("\u041F\u043E \u0443\u0431\u044B\u0432\u0430\u043D\u0438\u044E"),
+                  icon: /* @__PURE__ */ jsx31(SortDownIcon, {}),
+                  selected: sortBy.some((sb) => sb.columnName === headerResultName && sb.direction === "desc"),
+                  onClick: handleSortClick("desc")
+                }
+              ]
+            }
+          ) })
+        ] }),
+        children: /* @__PURE__ */ jsx31(Tooltip, { label: t("\u0421\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u043A\u0430 \u0438 \u0444\u0438\u043B\u044C\u0442\u0440\u0430\u0446\u0438\u044F"), placement: "bottom-end", children: /* @__PURE__ */ jsx31(
+          Button,
+          {
+            size: "small",
+            variant: "text",
+            textSecondary: true,
+            icon: hasAnyFilter ? /* @__PURE__ */ jsx31(FilterIcon, {}) : /* @__PURE__ */ jsx31(ArrowDropDownIcon, {})
+          }
+        ) })
+      }
+    )
+  ] });
+}
+
+// src/components/view/VirtualTable/utils/getColumns.ts
+var createMeta = (column) => {
+  if (column) {
+    return {
+      editable: column.editable,
+      sortable: column.sortable,
+      sortAnotherName: column.sortAnotherName,
+      filterable: column.filterable,
+      width: column.width,
+      headerAlign: column.headerAlign,
+      rowsAlign: column.rowsAlign,
+      valueFormat: column.valueFormat,
+      showInModal: column.showInModal,
+      label: column.label,
+      verticalAlign: column.verticalAlign,
+      toFixed: column.toFixed
+    };
+  }
+};
+var getColumns = (columns, parent) => {
+  return columns.map((column) => ({
+    id: column.id,
+    accessorKey: column.accessorKey,
+    accessorFn: column.accessorKey ? (row) => row[column.accessorKey]?.value : void 0,
+    header: () => column.label,
+    meta: createMeta(!!parent?.accessorKey ? parent : column),
+    columns: column.columns ? getColumns(column.columns, column) : void 0
+  }));
+};
+
+// src/components/view/VirtualTable/utils/getNextHorizontalHeaders.ts
+var getNextHorizontalHeaders = (headers, currentIndex, lastVirtualColumnIndex) => {
+  if (headers[currentIndex + 1] && headers[currentIndex].column.columnDef.id === headers[currentIndex + 1].column.columnDef.id && currentIndex < lastVirtualColumnIndex) {
+    const result = [headers[currentIndex + 1]];
+    return result.concat(getNextHorizontalHeaders(headers, currentIndex + 1, lastVirtualColumnIndex));
+  }
+  return [];
+};
+
+// src/components/view/VirtualTable/utils/getPrevHorizontalHeaders.ts
+var getPrevHorizontalHeaders = (headers, currentIndex) => {
+  if (headers[currentIndex - 1] && headers[currentIndex - 1].column.columnDef.id === headers[currentIndex].column.columnDef.id) {
+    const result = [headers[currentIndex - 1]];
+    return result.concat(getPrevHorizontalHeaders(headers, currentIndex - 1));
+  }
+  return [];
+};
+
+// src/components/view/VirtualTable/utils/getPrevVerticalHeaders.ts
+var getPrevVerticalHeaders = (headersGroups, groupIndex, columnIndex) => {
+  if (headersGroups[groupIndex - 1] && !headersGroups[groupIndex - 1].headers[columnIndex].column.columnDef.meta?.label) {
+    const result = [headersGroups[groupIndex - 1].headers[columnIndex]];
+    return result.concat(getPrevVerticalHeaders(headersGroups, groupIndex - 1, columnIndex));
+  }
+  return [];
+};
+
+// src/components/view/VirtualTable/utils/recursiveFilter.ts
+var recursiveFilter = (items, filterBy) => {
+  if (filterBy.length) {
+    const filterByItem = filterBy[filterBy.length - 1];
+    const filtered = filterByItem.values.length ? items.filter(
+      (item) => filterByItem.values.includes(item[filterByItem.columnName]?.value?.toString() ?? "") || item.isNew?.value === 1
+    ) : items;
+    return recursiveFilter(filtered, filterBy.slice(0, filterBy.length - 1));
+  }
+  return items;
+};
+
+// src/components/view/VirtualTable/utils/recursiveSort.ts
+var recursiveSort = (items, sortBy) => {
+  if (sortBy.length) {
+    const sortByItem = sortBy[sortBy.length - 1];
+    const sorted = items.sort((a, b) => {
+      const aValue = a[sortByItem.columnName]?.value?.toString() ?? "";
+      const bValue = b[sortByItem.columnName]?.value?.toString() ?? "";
+      const compare = aValue.localeCompare(bValue);
+      return sortByItem.direction === "asc" ? compare : -compare;
+    });
+    return recursiveSort(sorted, sortBy.slice(0, sortBy.length - 1));
+  }
+  return items;
+};
+
+// src/components/view/VirtualTable/VirtualTable.tsx
+import { jsx as jsx32, jsxs as jsxs18 } from "react/jsx-runtime";
+function VirtualTable(props) {
+  const {
+    rows,
+    columns,
+    additionalColumnsViews,
+    onChangeCell,
+    cellWidth,
+    rowButtons,
+    fixedColumnsCount = 0,
+    headerRowHeight = [defaultRowHeight],
+    bodyRowHeight = defaultRowHeight,
+    rowActionWidth = 77,
+    classes,
+    // При локальной разработке с динамической высотой строк нужно отключать StrictMode,
+    // потому что вместо одного рендера происходит 2
+    dynamicRowHeight = false
+  } = props;
+  const [filterBy, setFilterBy] = useState13([]);
+  const [sortBy, setSortBy] = useState13([{ columnName: "isNew", direction: "desc" }]);
+  const memoizedColumns = useMemo7(() => getColumns(columns), [columns]);
+  const memoizedData = useMemo7(() => {
+    const newRows = [...rows];
+    const nextFilterBy = filterBy.filter(
+      (i) => rows.some((r) => i.values.includes(r[i.columnName]?.value?.toString() ?? ""))
+    );
+    const filtered = nextFilterBy.length ? recursiveFilter(newRows, nextFilterBy) : newRows;
+    const sorted = sortBy.length ? recursiveSort(filtered, sortBy) : filtered;
+    return sorted;
+  }, [rows, sortBy, filterBy]);
+  const columnsEstimateSize = useMemo7(
+    () => cellWidth ?? ((index) => memoizedColumns[index]?.meta?.width ?? 200),
+    [cellWidth, memoizedColumns]
+  );
+  const table = useReactTable({
+    data: memoizedData,
+    columns: memoizedColumns,
+    defaultColumn: DefaultColumn,
+    manualSorting: true,
+    getCoreRowModel: getCoreRowModel(),
+    meta: {
+      updateData: (rowIndex, columnId, value, original) => {
+        onChangeCell?.(rowIndex, columnId, value, original);
+      },
+      additionalColumnsViews
+    }
+  });
+  const tableContainerRef = useRef10(null);
+  const { rows: rowsFromTable } = table.getRowModel();
+  const headerGroups = table.getHeaderGroups();
+  const tableContainer = tableContainerRef?.current;
+  const measureElement = useMemo7(() => {
+    if (dynamicRowHeight && tableContainer) {
+      return (e, _, b) => {
+        const dataIndex = e.getAttribute("data-index");
+        let height = e.clientHeight + 1;
+        if (dataIndex && height !== b.measurementsCache[+dataIndex].size) {
+          const rowCells = Array.from(tableContainer.querySelectorAll(`[data-index='${dataIndex}']`)) ?? [];
+          const cellsHeights = rowCells.map((cell) => cell.getBoundingClientRect().height);
+          height = Math.max(...cellsHeights);
+          b.resizeItem(+dataIndex, height);
+        }
+        return height;
+      };
+    }
+  }, [dynamicRowHeight, tableContainer]);
+  const rowVirtualizer = useVirtualizer({
+    count: rowsFromTable.length,
+    getScrollElement: () => tableContainerRef?.current,
+    estimateSize: useCallback7(() => bodyRowHeight, []),
+    measureElement,
+    overscan: 2
+  });
+  const columnVirtualizer = useVirtualizer({
+    horizontal: true,
+    count: rowsFromTable[0]?.getAllCells().length ?? 1,
+    getScrollElement: () => tableContainerRef?.current,
+    overscan: 2,
+    estimateSize: columnsEstimateSize
+  });
+  const {
+    getVirtualItems: getVirtualRows,
+    getTotalSize: getRowsTotalSize,
+    measurementsCache,
+    resizeItem
+  } = rowVirtualizer;
+  const { getVirtualItems: getVirtualColumns, getTotalSize: getColumnsTotalSize } = columnVirtualizer;
+  useEffect8(() => {
+    measurementsCache.forEach((i) => {
+      resizeItem(i.index, bodyRowHeight);
+    });
+  }, [rowsFromTable]);
+  const [windowWidth, windowHeight] = useWindowSize();
+  const headerGroupHeight = useMemo7(() => {
+    const delta = headerGroups.length - headerRowHeight.length;
+    const result = [...headerRowHeight];
+    if (delta > 0) {
+      for (let i = 0; i < delta; i++) {
+        result.push(defaultRowHeight);
+      }
+    }
+    return result;
+  }, [headerRowHeight, headerGroups]);
+  const summaryHeaderHeight = useMemo7(
+    () => headerGroupHeight.reduce(
+      (sum, current, currentIndex) => currentIndex < headerGroups.length ? sum + current : sum,
+      0
+    ),
+    [headerGroupHeight, headerGroups]
+  );
+  const headerGroupY = useCallback7(
+    (headerIndex) => headerGroupHeight.reduce((sum, current, currentIndex) => currentIndex < headerIndex ? sum + current : sum, 0),
+    [headerGroupHeight, headerGroups]
+  );
+  const rowsTotalSize = getRowsTotalSize();
+  const calculateRightAndBottomBorders = useCallback7(
+    function(container) {
+      const rightBorderElement = container.querySelector(`.${virtualTable_default.rightBorder}`);
+      if (rightBorderElement) {
+        const containerWidth = container.clientWidth;
+        const tableWidth = getColumnsTotalSize() + (!!rowButtons ? rowActionWidth : 0);
+        rightBorderElement.style.left = `${containerWidth > tableWidth ? tableWidth : containerWidth}px`;
+      }
+      const bottomBorderElement = container.querySelector(`.${virtualTable_default.bottomBorder}`);
+      if (bottomBorderElement) {
+        const containerHeight = container.clientHeight;
+        const tableHeight = rowsTotalSize + summaryHeaderHeight;
+        bottomBorderElement.style.top = `${containerHeight > tableHeight ? tableHeight : containerHeight}px`;
+      }
+    },
+    [rowButtons, rowsTotalSize]
+  );
+  useEffect8(() => {
+    if (tableContainerRef?.current) {
+      calculateRightAndBottomBorders(tableContainerRef?.current);
+    }
+  }, [windowWidth, windowHeight, tableContainerRef, rowsTotalSize]);
+  useEffect8(() => {
+    const scrollListener = function() {
+      const marginTopChangingElements = this.querySelectorAll(`.${virtualTable_default.marginTopChanging}`);
+      marginTopChangingElements?.forEach(
+        (element) => element.style.marginTop = `${this.scrollTop}px`
+      );
+      const marginLeftChangingElements = this.querySelectorAll(`.${virtualTable_default.marginLeftChanging}`);
+      marginLeftChangingElements?.forEach(
+        (element) => element.style.marginLeft = `${this.scrollLeft}px`
+      );
+    };
+    if (tableContainerRef?.current) {
+      tableContainerRef.current.addEventListener("scroll", scrollListener);
+      tableContainerRef.current.scrollTo(0, tableContainerRef.current.scrollHeight);
+    }
+    return () => {
+      if (tableContainerRef?.current) {
+        tableContainerRef.current.removeEventListener("scroll", scrollListener);
+      }
+    };
+  }, [tableContainerRef]);
+  const virtualRows = getVirtualRows();
+  const virtualColumns = getVirtualColumns();
+  const lastVirtualColumnIndex = virtualColumns[virtualColumns.length - 1]?.index;
+  return /* @__PURE__ */ jsx32("div", { className: classnames21(virtualTable_default.root, classes?.root), children: /* @__PURE__ */ jsxs18("div", { ref: tableContainerRef, className: classnames21(virtualTable_default.tableContainer, "styledScroll"), children: [
+    /* @__PURE__ */ jsxs18(
+      "div",
+      {
+        className: virtualTable_default.table,
+        style: {
+          width: `${getColumnsTotalSize() + (!!rowButtons ? rowActionWidth : 0)}px`,
+          height: `${rowsTotalSize + summaryHeaderHeight}px`
+        },
+        children: [
+          headerGroups.map((headerGroup, hgi) => {
+            const innerCell = (header) => {
+              const headerMeta = header.column.columnDef.meta;
+              return /* @__PURE__ */ jsx32("div", { className: classnames21(virtualTable_default.thCell), children: header.column.columnDef.id === header.column.columnDef["accessorKey"] && (headerMeta?.sortable || headerMeta?.filterable) ? /* @__PURE__ */ jsx32(
+                HeaderDropdown,
+                {
+                  sortable: headerMeta?.sortable ?? false,
+                  sortBy,
+                  setSortBy,
+                  sortAnotherName: headerMeta?.sortAnotherName,
+                  filterable: headerMeta?.filterable ?? false,
+                  filterBy,
+                  setFilterBy,
+                  items: rows,
+                  headerName: header.column.columnDef.id ?? header.id,
+                  children: /* @__PURE__ */ jsx32(
+                    "div",
+                    {
+                      className: classnames21(
+                        virtualTable_default.label,
+                        !!headerMeta?.headerAlign ? virtualTable_default[`align${headerMeta?.headerAlign}`] : virtualTable_default.alignLeft
+                      ),
+                      children: flexRender(header.column.columnDef.header, header.getContext())
+                    }
+                  )
+                }
+              ) : /* @__PURE__ */ jsx32(
+                "div",
+                {
+                  className: classnames21(
+                    virtualTable_default.label,
+                    !!headerMeta?.headerAlign ? virtualTable_default[`align${headerMeta?.headerAlign}`] : virtualTable_default.alignLeft
+                  ),
+                  children: flexRender(header.column.columnDef.header, header.getContext())
+                }
+              ) });
+            };
+            return /* @__PURE__ */ jsxs18(Fragment6, { children: [
+              [...Array(fixedColumnsCount)].map((_, index) => {
+                const header = headerGroup.headers[index];
+                return /* @__PURE__ */ jsx32(
+                  "div",
+                  {
+                    className: classnames21(
+                      virtualTable_default.th,
+                      hgi === 0 ? virtualTable_default.firstThRow : void 0,
+                      virtualTable_default.marginTopChanging,
+                      virtualTable_default.marginLeftChanging,
+                      index === fixedColumnsCount - 1 ? virtualTable_default.marginLeftChangingLast : void 0
+                    ),
+                    style: {
+                      zIndex: 3,
+                      width: `${columnsEstimateSize(index)}px`,
+                      height: `${headerGroupHeight[hgi]}px`,
+                      transform: `translateX(${index > 0 ? columnsEstimateSize(index - 1) : 0}px) translateY(${headerGroupY(hgi)}px)`
+                    },
+                    children: innerCell(header)
+                  },
+                  `${headerGroup.id}-${header.id}`
+                );
+              }),
+              virtualColumns.map((column) => {
+                if (column.index > fixedColumnsCount - 1) {
+                  const header = headerGroup.headers[column.index];
+                  const nextHorizontalHeaders = getNextHorizontalHeaders(
+                    headerGroup.headers,
+                    column.index,
+                    lastVirtualColumnIndex
+                  );
+                  const prevHorizontalHeaders = getPrevHorizontalHeaders(headerGroup.headers, column.index);
+                  const prevVerticalHeaders = getPrevVerticalHeaders(headerGroups, hgi, column.index);
+                  const width = !nextHorizontalHeaders.length && !prevHorizontalHeaders.length ? column.size : column.size + nextHorizontalHeaders.reduce(
+                    (sum, current) => sum + (current.column.columnDef.meta?.width ?? 0),
+                    0
+                  );
+                  const zIndex = !nextHorizontalHeaders.length && !prevHorizontalHeaders.length ? void 0 : nextHorizontalHeaders.length + 2;
+                  const height = !prevVerticalHeaders.length ? headerGroupHeight[hgi] : headerGroupHeight[hgi] + prevVerticalHeaders.reduce(
+                    (sum, _, index) => sum + (headerGroupHeight[hgi - index - 1] ?? 0),
+                    0
+                  );
+                  const translateY = !prevVerticalHeaders.length ? headerGroupY(hgi) : headerGroupY(hgi) - prevVerticalHeaders.reduce(
+                    (sum, _, index) => sum + (headerGroupHeight[hgi - index - 1] ?? 0),
+                    0
+                  );
+                  return /* @__PURE__ */ jsx32(
+                    "div",
+                    {
+                      className: classnames21(
+                        virtualTable_default.th,
+                        hgi === 0 ? virtualTable_default.firstThRow : void 0,
+                        virtualTable_default.marginTopChanging
+                      ),
+                      style: {
+                        width: `${width}px`,
+                        zIndex,
+                        height: `${height}px`,
+                        transform: `translateX(${column.start}px) translateY(${translateY}px)`,
+                        borderTop: translateY === 0 ? "1px solid var(--border-color)" : void 0
+                      },
+                      children: innerCell(header)
+                    },
+                    `${headerGroup.id}-${header.id}`
+                  );
+                }
+                return null;
+              }),
+              !!rowButtons && /* @__PURE__ */ jsx32(
+                "div",
+                {
+                  className: classnames21(
+                    virtualTable_default.th,
+                    hgi === 0 ? virtualTable_default.firstThRow : void 0,
+                    virtualTable_default.marginTopChanging
+                  ),
+                  style: {
+                    width: `${rowActionWidth}px`,
+                    height: `${headerGroupHeight[hgi]}px`,
+                    transform: `translateX(${getColumnsTotalSize()}px) translateY(${headerGroupY(hgi)}px)`
+                  }
+                }
+              )
+            ] }, headerGroup.id);
+          }),
+          virtualRows.map((virtualRow) => {
+            const row = rowsFromTable[virtualRow.index];
+            let height = bodyRowHeight;
+            if (dynamicRowHeight) {
+              const rowSizeFromCache = virtualRow.size;
+              height = rowSizeFromCache === bodyRowHeight ? void 0 : rowSizeFromCache;
+            }
+            if (height) {
+              height = `${height}px`;
+            }
+            return /* @__PURE__ */ jsxs18(Fragment6, { children: [
+              [...Array(fixedColumnsCount)].map((_, index) => {
+                const cell = row.getAllCells()[index];
+                return /* @__PURE__ */ jsx32(
+                  "div",
+                  {
+                    className: classnames21(
+                      virtualTable_default.td,
+                      virtualTable_default.marginLeftChanging,
+                      index === fixedColumnsCount - 1 ? virtualTable_default.marginLeftChangingLast : void 0,
+                      row.original?.isNew?.value === 1 ? virtualTable_default.selected : void 0
+                    ),
+                    style: {
+                      width: `${columnsEstimateSize(index)}px`,
+                      height,
+                      zIndex: 2,
+                      transform: `translateX(${index > 0 ? columnsEstimateSize(index - 1) : 0}px) translateY(${summaryHeaderHeight + virtualRow.start}px)`
+                    },
+                    children: flexRender(cell.column.columnDef.cell, cell.getContext())
+                  },
+                  `${cell.id}}`
+                );
+              }),
+              virtualColumns.map((column) => {
+                if (column.index > fixedColumnsCount - 1) {
+                  const cell = row.getAllCells()[column.index];
+                  return /* @__PURE__ */ jsx32(
+                    "div",
+                    {
+                      className: classnames21(
+                        virtualTable_default.td,
+                        virtualRow.index % 2 !== 0 ? virtualTable_default.evenRow : void 0,
+                        row.original?.isNew?.value === 1 ? virtualTable_default.selected : void 0
+                      ),
+                      style: {
+                        width: `${column.size}px`,
+                        height,
+                        transform: `translateX(${column.start}px) translateY(${summaryHeaderHeight + virtualRow.start}px)`
+                      },
+                      "data-index": virtualRow.index,
+                      ref: dynamicRowHeight ? rowVirtualizer.measureElement : void 0,
+                      children: flexRender(cell.column.columnDef.cell, cell.getContext())
+                    },
+                    `${cell.id}`
+                  );
+                }
+                return null;
+              }),
+              !!rowButtons && /* @__PURE__ */ jsx32(
+                "div",
+                {
+                  className: classnames21(virtualTable_default.td, row.original?.isNew?.value === 1 ? virtualTable_default.selected : void 0),
+                  style: {
+                    width: `${rowActionWidth}px`,
+                    height,
+                    transform: `translateX(${getColumnsTotalSize()}px) translateY(${summaryHeaderHeight + virtualRow.start}px)`,
+                    justifyContent: "flex-start",
+                    padding: "4px"
+                  },
+                  children: rowButtons?.(row.original)?.map((ab) => /* @__PURE__ */ jsx32(Fragment6, { children: ab.template ? ab.template(ab) : /* @__PURE__ */ jsx32(Tooltip, { label: ab.title, placement: "top", wrapTrigger: true, children: /* @__PURE__ */ jsx32(
+                    Button,
+                    {
+                      onClick: () => ab.onClick?.(virtualRow.index, row.original),
+                      size: "small",
+                      variant: "text",
+                      icon: ab.icon
+                    }
+                  ) }) }, ab.title))
+                }
+              )
+            ] }, `${row.id}`);
+          })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx32("div", { className: virtualTable_default.rightBorder, style: { height: `${rowsTotalSize + summaryHeaderHeight}px` } }),
+    /* @__PURE__ */ jsx32("div", { className: virtualTable_default.bottomBorder, style: { width: `${getColumnsTotalSize()}px` } })
+  ] }) });
+}
+
+// src/components/view/TreeView/TreeView.tsx
+import { memo as memo2, useCallback as useCallback8, useMemo as useMemo8, useState as useState15 } from "react";
+
+// src/components/view/TreeView/treeView.module.css
+var treeView_default = {
+  search: "treeView_search"
+};
+
+// src/components/view/TreeView/ui/TreeViewItem/TreeViewItem.tsx
+import classNames4 from "classnames";
+import { memo, useEffect as useEffect9, useState as useState14 } from "react";
+
+// src/components/view/TreeView/ui/TreeViewItem/treeViewItem.module.css
+var treeViewItem_default = {
+  item: "treeViewItem_item",
+  selectable: "treeViewItem_selectable",
+  children: "treeViewItem_children",
+  title: "treeViewItem_title",
+  selected: "treeViewItem_selected",
+  selectIcon: "treeViewItem_selectIcon"
+};
+
+// src/components/view/TreeView/ui/TreeViewItem/TreeViewItem.tsx
+import { jsx as jsx33, jsxs as jsxs19 } from "react/jsx-runtime";
+var TreeViewItem_default = memo(function TreeViewItem({
+  title,
+  value,
+  searchValue,
+  selected,
+  onSelect,
+  type,
+  isSelectable,
+  startIcons,
+  children
+}) {
+  const [isOpen, setIsOpen] = useState14(false);
+  useEffect9(() => {
+    setIsOpen(!!searchValue);
+  }, [searchValue]);
+  const hasChildren = !!children?.length;
+  const startIcon = type && startIcons?.[type];
+  const handleClick = () => {
+    if (isSelectable && onSelect) {
+      onSelect(value);
+    } else {
+      setIsOpen(!isOpen);
+    }
+  };
+  const isSelected = selected[value];
+  return /* @__PURE__ */ jsxs19("div", { children: [
+    /* @__PURE__ */ jsxs19("div", { className: classNames4(treeViewItem_default.item, { [treeViewItem_default.selectable]: isSelectable }), onClick: handleClick, children: [
+      hasChildren && /* @__PURE__ */ jsx33(KeyboardArrowDownIcon, {}),
+      /* @__PURE__ */ jsxs19("div", { className: classNames4(treeViewItem_default.title, { [treeViewItem_default.selected]: isSelected }), children: [
+        startIcon,
+        /* @__PURE__ */ jsx33(Typography, { variant: "subtitle2", children: title }),
+        isSelectable && /* @__PURE__ */ jsx33("span", { className: treeViewItem_default.selectIcon, children: isSelected ? /* @__PURE__ */ jsx33(DoneIcon, {}) : /* @__PURE__ */ jsx33(AddIcon, {}) })
+      ] })
+    ] }),
+    isOpen && hasChildren && /* @__PURE__ */ jsx33("div", { className: treeViewItem_default.children, children: children.map((c) => /* @__PURE__ */ jsx33(
+      TreeViewItem,
+      {
+        title: c.name,
+        value: c.id,
+        children: c.children,
+        selected,
+        searchValue,
+        type: c.type,
+        isSelectable: c.isSelectable,
+        startIcons,
+        onSelect
+      },
+      c.id
+    )) })
+  ] });
+});
+
+// src/components/view/TreeView/utils/getFilteredTree.ts
+var getFilteredTree = (tree, search) => {
+  const lowerCasedSearch = search.toLowerCase();
+  const getChildren = (acc, cur) => {
+    if (cur.name.toLowerCase().includes(lowerCasedSearch)) {
+      acc.push(cur);
+      return acc;
+    }
+    if (Array.isArray(cur.children)) {
+      const children = cur.children.reduce(getChildren, []);
+      if (children.length)
+        acc.push({ ...cur, children });
+    }
+    return acc;
+  };
+  return tree.reduce(getChildren, []);
+};
+
+// src/components/view/TreeView/TreeView.tsx
+import { Fragment as Fragment7, jsx as jsx34, jsxs as jsxs20 } from "react/jsx-runtime";
+var TreeView_default = memo2(function TreeView({ data, selected, startIcons, onSelect, withSearch = false }) {
+  const [searchValue, setSearchValue] = useState15("");
+  const onChangeSearchValue = useCallback8((e) => setSearchValue(e.target.value), []);
+  const selectedValues = useMemo8(
+    () => selected.reduce(
+      (acc, cur) => {
+        acc[cur] = true;
+        return acc;
+      },
+      {}
+    ),
+    [selected]
+  );
+  const filteredData = useMemo8(() => {
+    return getFilteredTree(data, searchValue);
+  }, [data, searchValue]);
+  return /* @__PURE__ */ jsxs20(Fragment7, { children: [
+    withSearch && /* @__PURE__ */ jsx34(
+      SearchInput,
+      {
+        variant: "outlined",
+        value: searchValue,
+        fullWidth: true,
+        onChange: onChangeSearchValue,
+        classes: { root: treeView_default.search }
+      }
+    ),
+    /* @__PURE__ */ jsx34("div", { className: "styledScroll", children: filteredData.map(({ id, name, children }) => {
+      return /* @__PURE__ */ jsx34(
+        TreeViewItem_default,
+        {
+          title: name,
+          value: id,
+          searchValue,
+          children,
+          startIcons,
+          onSelect,
+          selected: selectedValues
+        },
+        id
+      );
+    }) })
+  ] });
+});
+
+// src/components/view/Pairs/Pairs.tsx
+import classNames5 from "classnames";
+
+// src/components/view/Pairs/pairs.module.css
+var pairs_default = {
+  rowContainerBorders: "pairs_rowContainerBorders",
+  labelsContainer: "pairs_labelsContainer",
+  labelsWithBorders: "pairs_labelsWithBorders",
+  valuesContainer: "pairs_valuesContainer",
+  valuesWithBorders: "pairs_valuesWithBorders",
+  dimTypography: "pairs_dimTypography",
+  trimmedTypography: "pairs_trimmedTypography"
+};
+
+// src/components/view/Pairs/ui/TypographyWithTooltip.tsx
+import { useState as useState16 } from "react";
+import { jsx as jsx35 } from "react/jsx-runtime";
+function TypographyWithTooltip(props) {
+  const { label } = props;
+  const [tooltip, setTooltip] = useState16(label);
+  return /* @__PURE__ */ jsx35(Tooltip, { label: tooltip, children: /* @__PURE__ */ jsx35(
+    Typography,
+    {
+      style: {
+        textOverflow: "ellipsis",
+        overflow: "hidden",
+        whiteSpace: "nowrap"
+      },
+      onMouseEnter: (e) => {
+        setTooltip(e.currentTarget.scrollWidth > e.currentTarget.clientWidth ? label : "");
+      },
+      children: label
+    }
+  ) });
+}
+
+// src/components/view/Pairs/Pairs.tsx
+import { Fragment as Fragment8, jsx as jsx36, jsxs as jsxs21 } from "react/jsx-runtime";
+function Pairs(props) {
+  const { pairs, column1Width = "50%", column2Width = "50%", showBorder, minRowHeight, classes } = props;
+  return /* @__PURE__ */ jsx36("div", { className: classNames5(classes?.root), children: pairs.map((pair, i) => /* @__PURE__ */ jsx36(
+    "div",
+    {
+      style: { minHeight: minRowHeight, display: "flex" },
+      className: classNames5(classes?.rowContainer, {
+        [pairs_default.rowContainerBorders]: showBorder
+      }),
+      children: pair && /* @__PURE__ */ jsxs21(Fragment8, { children: [
+        /* @__PURE__ */ jsx36(
+          "div",
+          {
+            className: classNames5(pairs_default.labelsContainer, classes?.labelsContainer, {
+              [pairs_default.labelsWithBorders]: showBorder
+            }),
+            style: {
+              width: column1Width,
+              minWidth: column1Width
+            },
+            children: /* @__PURE__ */ jsx36(Typography, { className: pairs_default.dimTypography, children: pair.label })
+          }
+        ),
+        /* @__PURE__ */ jsx36(
+          "div",
+          {
+            style: {
+              width: column2Width,
+              minWidth: column2Width
+            },
+            className: classNames5(pairs_default.valuesContainer, classes?.valuesContainer, {
+              [pairs_default.valuesWithBorders]: showBorder
+            }),
+            children: /* @__PURE__ */ jsx36(TypographyWithTooltip, { label: pair.value })
+          }
+        )
+      ] })
+    },
+    i
+  )) });
+}
+
+// src/components/view/Card/Card.tsx
+import classNames6 from "classnames";
+
+// src/components/view/Card/card.module.css
+var card_default = {
+  root: "card_root",
+  header: "card_header",
+  actions: "card_actions"
+};
+
+// src/components/view/Card/Card.tsx
+import { jsx as jsx37, jsxs as jsxs22 } from "react/jsx-runtime";
+function Card(props) {
+  const { surfaceType = "primary", title, actions, children, classes } = props;
+  return /* @__PURE__ */ jsxs22(Surface, { type: surfaceType, classes: { root: classNames6(card_default.root, classes?.root) }, children: [
+    (!!title || !!actions) && /* @__PURE__ */ jsxs22("div", { className: card_default.header, children: [
+      title ?? /* @__PURE__ */ jsx37("div", {}),
+      !!actions && /* @__PURE__ */ jsx37("div", { className: classNames6(card_default.actions, classes?.actions), children: actions })
+    ] }),
+    /* @__PURE__ */ jsx37("div", { className: classNames6(classes?.body), children })
+  ] });
+}
+export {
+  Button,
+  ButtonsGroup,
+  Card,
+  Checkbox,
+  Checklist,
+  ColorPicker,
+  DateTime,
+  Input,
+  Layout,
+  Menu,
+  Modal,
+  MultiSelect,
+  Pairs,
+  Popover,
+  SearchInput,
+  Select,
+  Surface,
+  Tabs,
+  Tooltip,
+  TreeView_default as TreeView,
+  Typography,
+  VirtualTable,
+  WrapForLabel
+};