@max-ts/components 0.1.1 → 0.2.0

package/lib/components/DataGrid/Row/useLogic/utils/mergeColumnsOptions/mergeColumnsOptions.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../getColumnsMap/getColumnsMap.cjs"),s=(t,r)=>{if(!r)return t;const n=i.getColumnsMap(r);return Object.keys(n).length?t.map(e=>e.hasOwnProperty("field")?{...e,...n[e.field]||{}}:e):t};exports.mergeColumnsOptions=s;

package/lib/components/DataGrid/Row/useLogic/utils/mergeColumnsOptions/mergeColumnsOptions.d.ts

@@ -0,0 +1,2 @@
+import { CellValue, DataGridColumns, DataGridRowOptionColumns } from '../../../../types';
+export declare const mergeColumnsOptions: <TData extends Record<string, CellValue>>(columns: DataGridColumns<TData>[], childrenColumns: DataGridRowOptionColumns<TData>[] | undefined) => any[];

package/lib/components/DataGrid/Row/useLogic/utils/mergeColumnsOptions/mergeColumnsOptions.mjs

@@ -0,0 +1,14 @@
+import { getColumnsMap as n } from "../getColumnsMap/getColumnsMap.mjs";
+const f = (e, t) => {
+  if (!t)
+    return e;
+  const i = n(t);
+  return Object.keys(i).length ? e.map((r) => r.hasOwnProperty("field") ? {
+    ...r,
+    // @ts-ignore
+    ...i[r.field] || {}
+  } : r) : e;
+};
+export {
+  f as mergeColumnsOptions
+};

package/lib/components/DataGrid/Row/utils/checkIsDisabled/checkIsDisabled.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const c=(r,e,t)=>r?e?!e.includes(t):!0:!1;exports.checkIsDisabled=c;

package/lib/components/DataGrid/Row/utils/checkIsDisabled/checkIsDisabled.mjs

@@ -0,0 +1,4 @@
+const u = (e, r, t) => e ? r ? !r.includes(t) : !0 : !1;
+export {
+  u as checkIsDisabled
+};

package/lib/components/DataGrid/constants.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const E=44,_=32,T=_/2,I=10,D=1,L=2;exports.EXPANDED_LEVEL_BY_DEFAULT=D;exports.INITIAL_OPENED_NESTED_CHILDREN_COUNT_BY_DEFAULT=L;exports.MIN_DISPLAY_ROWS_BY_DEFAULT=I;exports.MIN_ROW_HEIGHT=E;exports.ROOT_ACTION_CELL_WIDTH=_;exports.TREE_LINE_WIDTH=T;

package/lib/components/DataGrid/constants.mjs

@@ -0,0 +1,9 @@
+const _ = 44, E = 32, T = 16, I = 10, L = 1, D = 2;
+export {
+  L as EXPANDED_LEVEL_BY_DEFAULT,
+  D as INITIAL_OPENED_NESTED_CHILDREN_COUNT_BY_DEFAULT,
+  I as MIN_DISPLAY_ROWS_BY_DEFAULT,
+  _ as MIN_ROW_HEIGHT,
+  E as ROOT_ACTION_CELL_WIDTH,
+  T as TREE_LINE_WIDTH
+};

package/lib/components/DataGrid/enums.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var r=(e=>(e.ASC="asc",e.DESC="desc",e))(r||{}),t=(e=>(e.Tree="tree",e.Subrows="subrows",e))(t||{});exports.SortStates=r;exports.Variant=t;

package/lib/components/DataGrid/enums.mjs

@@ -0,0 +1,5 @@
+var e = /* @__PURE__ */ ((r) => (r.ASC = "asc", r.DESC = "desc", r))(e || {}), s = /* @__PURE__ */ ((r) => (r.Tree = "tree", r.Subrows = "subrows", r))(s || {});
+export {
+  e as SortStates,
+  s as Variant
+};

package/lib/components/DataGrid/faker.d.ts

@@ -0,0 +1,24 @@
+import { CellValue, DataGridColumns, DataGridRowOptionColumns, DataGridRowOptions, DataGridRowWithOptions } from './types';
+type DataType = {
+    id: string;
+    documentName?: string;
+    recipient?: string;
+    createDate: string;
+    actions?: object;
+};
+type TreeDataType = {
+    id: string;
+    documentName: string;
+    recipient: string;
+    createDate: string;
+    actions?: object;
+};
+export declare const makeRandomDate: () => string;
+export declare const makeColumns: <T extends DataType>(columnsTemplate: DataGridColumns<T>[], mergedColumns?: DataGridColumns<T>[]) => DataGridColumns<T>[];
+export declare const makeDataList: <TData extends Record<string, CellValue>>(dataObjTemplate: TData, options?: DataGridRowOptions<TData>) => DataGridRowWithOptions<TData>[];
+export declare const makeDataListWithTree: (length?: number, options?: {
+    isNotSelectable?: boolean;
+    childrenCount?: number;
+    childrenColumns?: DataGridRowOptionColumns<TreeDataType>[];
+}) => TreeDataType[];
+export {};

package/lib/components/DataGrid/styles.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("@mui/material"),r=i.styled("div",{shouldForwardProp:e=>e!=="$maxHeight"})`
+  position: relative;
+
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+
+  width: 100%;
+  height: 100%;
+  max-height: ${({$maxHeight:e})=>e?`${e}px`:"initial"};
+`,t=i.styled("div")`
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+
+  height: 100%;
+`,a=i.styled(t)`
+  pointer-events: none;
+
+  background: ${({theme:e})=>e.palette.background.element};
+  mix-blend-mode: luminosity;
+`;exports.Container=r;exports.DataGridWrapper=t;exports.DisabledDataGridWrapper=a;

package/lib/components/DataGrid/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const Container: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & {
+    $maxHeight?: number;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const DataGridWrapper: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const DisabledDataGridWrapper: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme> & import('react').ClassAttributes<HTMLDivElement> & import('react').HTMLAttributes<HTMLDivElement>, {}, {}>;

package/lib/components/DataGrid/styles.mjs

@@ -0,0 +1,30 @@
+import { styled as i } from "@mui/material";
+const n = i("div", {
+  shouldForwardProp: (e) => e !== "$maxHeight"
+})`
+  position: relative;
+
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+
+  width: 100%;
+  height: 100%;
+  max-height: ${({ $maxHeight: e }) => e ? `${e}px` : "initial"};
+`, o = i("div")`
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+
+  height: 100%;
+`, d = i(o)`
+  pointer-events: none;
+
+  background: ${({ theme: e }) => e.palette.background.element};
+  mix-blend-mode: luminosity;
+`;
+export {
+  n as Container,
+  o as DataGridWrapper,
+  d as DisabledDataGridWrapper
+};

package/lib/components/DataGrid/types.d.ts

@@ -0,0 +1,91 @@
+import { CSSProperties, ReactNode } from 'react';
+import { SortStates } from './enums';
+export type AlignVariant = 'left' | 'center' | 'right';
+export type SortState = `${SortStates}`;
+export type RenderCell<Data> = (params: Data) => ReactNode;
+export type CellValue = unknown;
+export type DataGridSort<TSortField> = {
+    /**
+     * @example {fieldId: 'test'}
+     * Значение поля сортируемой колонки
+     */
+    fieldId: TSortField;
+    /**
+     * @example {sort: 'asc'}
+     * Значение возрастающий или убывающий сортировки (asc | desc)
+     */
+    sort: SortState;
+};
+export type DataGridColumns<TData extends Record<string, CellValue>> = {
+    /**
+     * @example {field: 'test'}
+     * Значение ключа поля данных для колонки
+     */
+    field?: keyof TData;
+    /**
+     * Название колонки таблицы
+     */
+    label?: string;
+    /**
+     * Если true, будет включена сортировка колонки
+     */
+    sortable?: boolean;
+    pointer?: boolean;
+    /**
+     * @example {renderCell: (row) => <div>Hello Cell</div>'}
+     * Кастомное отображение ячеек для колонки
+     */
+    renderCell?: RenderCell<TData>;
+    /**
+     * @example {format: (row) => new Date(row.createDate).toLocaleDateString()}
+     * Функция для кастомного форматирования данных ячеек для колонки
+     */
+    format?: (data: TData) => CellValue;
+    /**
+     * CSS свойство размещения контента в ячейке
+     */
+    align?: AlignVariant;
+    /**
+     * @example {width: '100%'}
+     * Ширина ячейка. Допустимые единицы: px, %, fr
+     */
+    width?: CSSProperties['width'];
+};
+export type DataGridRowOptionColumns<TData extends Record<string, CellValue>> = {
+    /**
+     * Значение ключа поля данных для колонки
+     */
+    field: keyof TData;
+    /**
+     * Кастомное отображение ячеек для колонки
+     */
+    renderCell?: RenderCell<TData>;
+};
+export type DataGridRowOptions<TData extends Record<string, CellValue>> = {
+    /**
+     * Если true, строка будет недоступна для взаимодействия
+     */
+    isDisabled?: boolean;
+    /**
+     * Если true, последняя ячейка не будет блокироваться при `isDisabled=true`
+     * @default 'true'
+     */
+    isDisabledLastCell?: boolean;
+    /**
+     * Если true, строка не будет доступна для выбора
+     */
+    isNotSelectable?: boolean;
+    /**
+     * Причина блокировки строки
+     */
+    disabledReason?: string;
+    /**
+     * Настройка отображения колонок дочерних элементов
+     */
+    childrenColumns?: DataGridRowOptionColumns<TData>[];
+};
+export type DataGridRow = Record<string, CellValue>;
+export type DataGridRowWithOptions<TData extends DataGridRow> = TData & {
+    options?: DataGridRowOptions<TData>;
+    children?: DataGridRowWithOptions<TData>[];
+};

package/lib/components/DataGrid/useLogic/useLogic.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("react"),A=require("../enums.cjs"),h=require("remeda"),E=require("./utils/getGridTemplateColumns/getGridTemplateColumns.cjs"),M=({keyId:t,columns:o,rows:r=[],variant:d,tree:m,subrows:C,selectedRows:i=[],isLoading:u,isDisabled:f,onSelectRow:n})=>{const q=!!r?.length,p=!!n,v=u||f,B=Object.is(d,A.Variant.Subrows)?{...C,isInitialExpanded:!0}:m,c=r.filter(e=>!(e.options?.isDisabled||e.options?.isNotSelectable)),b=a.useRef([]);a.useEffect(()=>{u||(b.current=r)},[r,u]);const g=E.getGridTemplateColumns(o),D=a.useMemo(()=>c.filter(e=>!i.find(l=>l[t]===e[t])).length,[c,i,t]),P=a.useCallback(()=>r.length<=1?o.map(e=>({...e,sortable:!1})):o,[o,r]),G=u?b.current:r,S=e=>{if(!n)return;if(e.target.checked){const s=h.uniqueBy([...i,...c],h.prop(t));return n(s)}const l=i.filter(s=>!r.find(j=>j[t]===s[t]));n(l)},T=a.useCallback(e=>l=>{if(n){if(l.target.checked)return n([...i,e]);n(i.filter(s=>s[t]!==e[t]))}},[i,n,t]);return{isDataGridDisabled:v,treeRenderConfig:B,renderRows:G,headProps:{rowsCount:c.length,uncheckedRowsCount:D,gridColumns:g,isSelectable:p,columns:P(),onSelectAllRows:S},bodyProps:{gridColumns:g,isSelectable:p,onSelectRow:T},loaderProps:{isLoading:q&&u,isVisibleDivider:!!r.length,isDisabled:f}}};exports.useLogic=M;

package/lib/components/DataGrid/useLogic/useLogic.d.ts

@@ -0,0 +1,32 @@
+import { ChangeEvent } from 'react';
+import { DataGridProps } from '../DataGrid';
+import { CellValue, DataGridRow } from '../types';
+type UseLogicParams<TData extends Record<string, CellValue> = DataGridRow, TSortField extends keyof TData = keyof TData> = DataGridProps<TData, TSortField>;
+export declare const useLogic: <TData extends Record<string, CellValue> = DataGridRow, TSortField extends keyof TData = keyof TData>({ keyId, columns, rows, variant, tree, subrows, selectedRows, isLoading, isDisabled, onSelectRow, }: UseLogicParams<TData, TSortField>) => {
+    isDataGridDisabled: boolean | undefined;
+    treeRenderConfig: {
+        isInitialExpanded?: boolean;
+        expandedLevel?: number;
+        initialVisibleChildrenCount?: number;
+    } | undefined;
+    renderRows: TData[];
+    headProps: {
+        rowsCount: number;
+        uncheckedRowsCount: number;
+        gridColumns: string;
+        isSelectable: boolean;
+        columns: import('../types').DataGridColumns<TData>[];
+        onSelectAllRows: (event: ChangeEvent<HTMLInputElement>) => void;
+    };
+    bodyProps: {
+        gridColumns: string;
+        isSelectable: boolean;
+        onSelectRow: (row: TData) => (event: ChangeEvent<HTMLInputElement>) => void;
+    };
+    loaderProps: {
+        isLoading: boolean | undefined;
+        isVisibleDivider: boolean;
+        isDisabled: boolean | undefined;
+    };
+};
+export {};

package/lib/components/DataGrid/useLogic/useLogic.mjs

@@ -0,0 +1,79 @@
+import { useRef as N, useEffect as V, useMemo as j, useCallback as h } from "react";
+import { Variant as q } from "../enums.mjs";
+import { uniqueBy as M, prop as O } from "remeda";
+import { getGridTemplateColumns as S } from "./utils/getGridTemplateColumns/getGridTemplateColumns.mjs";
+const J = ({
+  keyId: e,
+  columns: s,
+  rows: r = [],
+  variant: b,
+  tree: g,
+  subrows: C,
+  selectedRows: i = [],
+  isLoading: o,
+  isDisabled: u,
+  onSelectRow: n
+}) => {
+  const d = !!r?.length, c = !!n, B = o || u, D = Object.is(b, q.Subrows) ? { ...C, isInitialExpanded: !0 } : g, f = r.filter(
+    (t) => !(t.options?.isDisabled || t.options?.isNotSelectable)
+  ), p = N([]);
+  V(() => {
+    o || (p.current = r);
+  }, [r, o]);
+  const m = S(s), v = j(() => f.filter(
+    (t) => !i.find((l) => l[e] === t[e])
+  ).length, [f, i, e]), P = h(() => r.length <= 1 ? s.map((t) => ({ ...t, sortable: !1 })) : s, [s, r]), x = o ? p.current : r, A = (t) => {
+    if (!n)
+      return;
+    if (t.target.checked) {
+      const a = M(
+        [...i, ...f],
+        O(e)
+      );
+      return n(a);
+    }
+    const l = i.filter(
+      (a) => !r.find((G) => G[e] === a[e])
+    );
+    n(l);
+  }, E = h(
+    (t) => (l) => {
+      if (n) {
+        if (l.target.checked)
+          return n([...i, t]);
+        n(
+          i.filter(
+            (a) => a[e] !== t[e]
+          )
+        );
+      }
+    },
+    [i, n, e]
+  );
+  return {
+    isDataGridDisabled: B,
+    treeRenderConfig: D,
+    renderRows: x,
+    headProps: {
+      rowsCount: f.length,
+      uncheckedRowsCount: v,
+      gridColumns: m,
+      isSelectable: c,
+      columns: P(),
+      onSelectAllRows: A
+    },
+    bodyProps: {
+      gridColumns: m,
+      isSelectable: c,
+      onSelectRow: E
+    },
+    loaderProps: {
+      isLoading: d && o,
+      isVisibleDivider: !!r.length,
+      isDisabled: u
+    }
+  };
+};
+export {
+  J as useLogic
+};

package/lib/components/DataGrid/useLogic/utils/getGridTemplateColumns/getGridTemplateColumns.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=t=>t.map(({width:e})=>e||"1fr").join(" ");exports.getGridTemplateColumns=o;

package/lib/components/DataGrid/useLogic/utils/getGridTemplateColumns/getGridTemplateColumns.mjs

@@ -0,0 +1,4 @@
+const e = (t) => t.map(({ width: n }) => n || "1fr").join(" ");
+export {
+  e as getGridTemplateColumns
+};

package/lib/components/DataGrid/utils/alignToJustifyContent/alignToJustifyContent.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./constants.cjs"),e=T=>T&&t.ALIGN_TO_JUSTIFY_CONTENT_MAP[T]||t.DEFAULT_JUSTIFY_CONTENT;exports.alignToJustifyContent=e;

package/lib/components/DataGrid/utils/alignToJustifyContent/alignToJustifyContent.d.ts

@@ -0,0 +1,5 @@
+import { CSSProperties } from 'react';
+import { AlignVariant } from '../../types';
+type JustifyContentVariant = CSSProperties['justifyContent'];
+export declare const alignToJustifyContent: (align: AlignVariant | undefined) => JustifyContentVariant;
+export {};

package/lib/components/DataGrid/utils/alignToJustifyContent/alignToJustifyContent.mjs

@@ -0,0 +1,5 @@
+import { DEFAULT_JUSTIFY_CONTENT as t, ALIGN_TO_JUSTIFY_CONTENT_MAP as r } from "./constants.mjs";
+const _ = (T) => T ? r[T] || t : t;
+export {
+  _ as alignToJustifyContent
+};

package/lib/components/DataGrid/utils/alignToJustifyContent/constants.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const T="start",t={left:"start",center:"center",right:"end"};exports.ALIGN_TO_JUSTIFY_CONTENT_MAP=t;exports.DEFAULT_JUSTIFY_CONTENT=T;

package/lib/components/DataGrid/utils/alignToJustifyContent/constants.mjs

@@ -0,0 +1,9 @@
+const t = "start", T = {
+  left: "start",
+  center: "center",
+  right: "end"
+};
+export {
+  T as ALIGN_TO_JUSTIFY_CONTENT_MAP,
+  t as DEFAULT_JUSTIFY_CONTENT
+};

package/lib/components/DataGridActionCell/DataGridActionCell.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../../_virtual/jsx-runtime.cjs"),d=require("./MainAction/MainAction.cjs"),A=require("./SecondaryAction/SecondaryAction.cjs"),u=require("./styles.cjs"),m=require("./useLogic/useLogic.cjs"),r={mainAction:"top",secondaryAction:"left"},j=n=>{const{isDisabledAction:e,handleWrapperClick:a,handleActionClick:t}=m.useLogic(n),{actions:s}=n,{main:l,secondary:o}=s;return i.j.jsxs(u.Wrapper,{onClick:a,children:[l.map(c=>i.j.jsx(d.MainAction,{action:c,onActionClick:t,isDisabled:e,tooltipPlacement:r.mainAction},c.name)),o&&i.j.jsx(A.SecondaryActions,{actions:o,onActionClick:t,tooltipPlacement:r.secondaryAction,isDisabled:e})]})};exports.DataGridActionCell=j;

package/lib/components/DataGridActionCell/DataGridActionCell.d.ts

@@ -0,0 +1,22 @@
+import { MainActionKind, SecondaryActionKind } from './types';
+export type DataGridActions<TAction> = {
+    /**
+     * Основные действия
+     */
+    main: MainActionKind<TAction>[];
+    /**
+     * Вторичные действия
+     */
+    secondary?: SecondaryActionKind<TAction>[];
+};
+export type DataGridActionCellProps<TRow> = {
+    /**
+     * Действия
+     */
+    actions: DataGridActions<TRow>;
+    /**
+     * Данные строки
+     */
+    row: TRow;
+};
+export declare const DataGridActionCell: <TRow>(props: DataGridActionCellProps<TRow>) => import("react/jsx-runtime").JSX.Element;

package/lib/components/DataGridActionCell/DataGridActionCell.mjs

@@ -0,0 +1,35 @@
+import { j as o } from "../../_virtual/jsx-runtime.mjs";
+import { MainAction as m } from "./MainAction/MainAction.mjs";
+import { SecondaryActions as p } from "./SecondaryAction/SecondaryAction.mjs";
+import { Wrapper as A } from "./styles.mjs";
+import { useLogic as d } from "./useLogic/useLogic.mjs";
+const e = {
+  mainAction: "top",
+  secondaryAction: "left"
+}, u = (i) => {
+  const { isDisabledAction: n, handleWrapperClick: s, handleActionClick: t } = d(i), { actions: a } = i, { main: l, secondary: c } = a;
+  return /* @__PURE__ */ o.jsxs(A, { onClick: s, children: [
+    l.map((r) => /* @__PURE__ */ o.jsx(
+      m,
+      {
+        action: r,
+        onActionClick: t,
+        isDisabled: n,
+        tooltipPlacement: e.mainAction
+      },
+      r.name
+    )),
+    c && /* @__PURE__ */ o.jsx(
+      p,
+      {
+        actions: c,
+        onActionClick: t,
+        tooltipPlacement: e.secondaryAction,
+        isDisabled: n
+      }
+    )
+  ] });
+};
+export {
+  u as DataGridActionCell
+};

package/lib/components/DataGridActionCell/MainAction/MainAction.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../../../_virtual/jsx-runtime.cjs"),m=require("react"),q=require("../../IconDropdownButton/IconDropdownButton.cjs"),M=require("../../MenuItem/MenuItem.cjs"),p=require("../../Tooltip/Tooltip.cjs"),I=require("./MainIconButton/MainIconButton.cjs"),x=({action:e,onActionClick:t,isDisabled:r,tooltipPlacement:i})=>{if("actions"in e){const{disabled:o,icon:c,name:u,disabledReason:s,actions:l}=e;return n.j.jsx(p.Tooltip,{title:s||u,withoutContainer:!o,placement:i,children:n.j.jsx(q.IconDropdownButton,{icon:c,variant:"text",disabled:r||o,children:l.map(({name:a,onClick:d,...j})=>m.createElement(M.MenuItem,{...j,key:a,onClick:t(d)},a))})},u)}return n.j.jsx(I.MainIconButton,{action:e,onActionClick:t,isDisabled:r,tooltipPlacement:i})};exports.MainAction=x;

package/lib/components/DataGridActionCell/MainAction/MainAction.d.ts

@@ -0,0 +1,22 @@
+import { TooltipProps } from '../../Tooltip';
+import { ActionCellHandler, MainActionKind } from '../types';
+type MainActionProps<TAction> = {
+    /**
+     *  Основные действия
+     */
+    action: MainActionKind<TAction>;
+    /**
+     *  Обработчик клика на действие
+     */
+    onActionClick: ActionCellHandler<TAction>;
+    /**
+     *  Если true, action не доступен
+     */
+    isDisabled?: boolean;
+    /**
+     *  Положение тултипа
+     */
+    tooltipPlacement?: TooltipProps['placement'];
+};
+export declare const MainAction: <TAction>({ action, onActionClick, isDisabled, tooltipPlacement, }: MainActionProps<TAction>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/components/DataGridActionCell/MainAction/MainAction.mjs

@@ -0,0 +1,57 @@
+import { j as t } from "../../../_virtual/jsx-runtime.mjs";
+import { createElement as l } from "react";
+import { IconDropdownButton as u } from "../../IconDropdownButton/IconDropdownButton.mjs";
+import { MenuItem as x } from "../../MenuItem/MenuItem.mjs";
+import { Tooltip as j } from "../../Tooltip/Tooltip.mjs";
+import { MainIconButton as h } from "./MainIconButton/MainIconButton.mjs";
+const C = ({
+  action: o,
+  onActionClick: r,
+  isDisabled: n,
+  tooltipPlacement: i
+}) => {
+  if ("actions" in o) {
+    const { disabled: e, icon: p, name: m, disabledReason: s, actions: c } = o;
+    return /* @__PURE__ */ t.jsx(
+      j,
+      {
+        title: s || m,
+        withoutContainer: !e,
+        placement: i,
+        children: /* @__PURE__ */ t.jsx(
+          u,
+          {
+            icon: p,
+            variant: "text",
+            disabled: n || e,
+            children: c.map(
+              // @ts-ignore
+              ({ name: a, onClick: d, ...f }) => /* @__PURE__ */ l(
+                x,
+                {
+                  ...f,
+                  key: a,
+                  onClick: r(d)
+                },
+                a
+              )
+            )
+          }
+        )
+      },
+      m
+    );
+  }
+  return /* @__PURE__ */ t.jsx(
+    h,
+    {
+      action: o,
+      onActionClick: r,
+      isDisabled: n,
+      tooltipPlacement: i
+    }
+  );
+};
+export {
+  C as MainAction
+};

package/lib/components/DataGridActionCell/MainAction/MainIconButton/MainIconButton.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../../../../_virtual/jsx-runtime.cjs"),f=require("../../../ConfirmAction/ConfirmAction.cjs"),B=require("../../../IconButton/IconButton.cjs"),b=require("../../../Tooltip/Tooltip.cjs"),q=require("./useLogic/useLogic.cjs"),h=t=>{const{tooltipProps:s}=q.useLogic(t),{action:a,onActionClick:i,isDisabled:l,tooltipPlacement:u}=t,{name:d,icon:m,needConfirm:j,confirmText:C,confirmButtonProps:g,disabledReason:k,disabled:e,loading:p,isBlockingOperation:I,loadingNote:P,onClick:c,...x}=a,r=o=>n.j.jsx(b.Tooltip,{withoutContainer:!e,placement:u,...s,children:n.j.jsx(B.IconButton,{disabled:l||e,loading:p,...x,variant:"text",...o,children:m})},d);return n.j.jsx(n.j.Fragment,{children:j?n.j.jsx(f.ConfirmAction,{text:C,confirmButtonProps:g,actionComponent:o=>r(o),onConfirm:i(c)}):r({onClick:i(c)})})};exports.MainIconButton=h;

package/lib/components/DataGridActionCell/MainAction/MainIconButton/MainIconButton.d.ts

@@ -0,0 +1,19 @@
+import { IconButtonProps } from '../../../IconButton';
+import { TooltipProps } from '../../../Tooltip';
+import { ActionCellHandler, SingleAction } from '../../types';
+export type MainIconButtonProps<TAction> = {
+    action: IconButtonProps<'button'> & SingleAction<TAction>;
+    /**
+     *  Обработчик клика на действие
+     */
+    onActionClick: ActionCellHandler<TAction>;
+    /**
+     *  Если true, action не доступен
+     */
+    isDisabled?: boolean;
+    /**
+     *  Положение тултипа
+     */
+    tooltipPlacement?: TooltipProps['placement'];
+};
+export declare const MainIconButton: <TAction>(props: MainIconButtonProps<TAction>) => import("react/jsx-runtime").JSX.Element;

package/lib/components/DataGridActionCell/MainAction/MainIconButton/MainIconButton.mjs

@@ -0,0 +1,54 @@
+import { j as o } from "../../../../_virtual/jsx-runtime.mjs";
+import { ConfirmAction as g } from "../../../ConfirmAction/ConfirmAction.mjs";
+import { IconButton as B } from "../../../IconButton/IconButton.mjs";
+import { Tooltip as b } from "../../../Tooltip/Tooltip.mjs";
+import { useLogic as h } from "./useLogic/useLogic.mjs";
+const D = (t) => {
+  const { tooltipProps: s } = h(t), { action: m, onActionClick: i, isDisabled: a, tooltipPlacement: l } = t, {
+    name: d,
+    icon: p,
+    needConfirm: f,
+    confirmText: x,
+    confirmButtonProps: u,
+    disabledReason: k,
+    disabled: e,
+    loading: C,
+    isBlockingOperation: P,
+    loadingNote: A,
+    onClick: r,
+    ...j
+  } = m, c = (n) => /* @__PURE__ */ o.jsx(
+    b,
+    {
+      withoutContainer: !e,
+      placement: l,
+      ...s,
+      children: /* @__PURE__ */ o.jsx(
+        B,
+        {
+          disabled: a || e,
+          loading: C,
+          ...j,
+          variant: "text",
+          ...n,
+          children: p
+        }
+      )
+    },
+    d
+  );
+  return /* @__PURE__ */ o.jsx(o.Fragment, { children: f ? /* @__PURE__ */ o.jsx(
+    g,
+    {
+      text: x,
+      confirmButtonProps: u,
+      actionComponent: (n) => c(n),
+      onConfirm: i(r)
+    }
+  ) : c({
+    onClick: i(r)
+  }) });
+};
+export {
+  D as MainIconButton
+};

package/lib/components/DataGridActionCell/MainAction/MainIconButton/useLogic/useLogic.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("react"),r=({action:s})=>{const{loading:o,disabledReason:i,name:l}=s,[n,e]=t.useState(!1),a=()=>e(!0),c=()=>e(!1);return t.useEffect(()=>{o&&e(!1)},[o]),{tooltipProps:{title:i||l,open:n,onOpen:a,onClose:c}}};exports.useLogic=r;

package/lib/components/DataGridActionCell/MainAction/MainIconButton/useLogic/useLogic.d.ts

@@ -0,0 +1,11 @@
+import { MainIconButtonProps } from '../MainIconButton';
+type UseLogicParam<TAction> = MainIconButtonProps<TAction>;
+export declare const useLogic: <TAction>({ action }: UseLogicParam<TAction>) => {
+    tooltipProps: {
+        title: string;
+        open: boolean;
+        onOpen: () => void;
+        onClose: () => void;
+    };
+};
+export {};

package/lib/components/DataGridActionCell/MainAction/MainIconButton/useLogic/useLogic.mjs

@@ -0,0 +1,17 @@
+import { useState as a, useEffect as c } from "react";
+const d = ({ action: t }) => {
+  const { loading: e, disabledReason: s, name: l } = t, [i, o] = a(!1), n = () => o(!0), p = () => o(!1);
+  return c(() => {
+    e && o(!1);
+  }, [e]), {
+    tooltipProps: {
+      title: s || l,
+      open: i,
+      onOpen: n,
+      onClose: p
+    }
+  };
+};
+export {
+  d as useLogic
+};