ydb-embedded-ui 6.8.0 → 6.9.1

package/dist/components/PDiskPopup/PDiskPopup.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Popup } from '@gravity-ui/uikit';
+import { EFlag } from '../../types/api/enums';
+import { cn } from '../../utils/cn';
+import { EMPTY_DATA_PLACEHOLDER } from '../../utils/constants';
+import { getPDiskId } from '../../utils/dataFormatters/dataFormatters';
+import { bytesToGB } from '../../utils/utils';
+import { InfoViewer } from '../InfoViewer';
+import './PDiskPopup.scss';
+const b = cn('pdisk-storage-popup');
+const errorColors = [EFlag.Orange, EFlag.Red, EFlag.Yellow];
+export const preparePDiskData = (data, nodes) => {
+    const { AvailableSize, TotalSize, State, PDiskId, NodeId, Path, Realtime, Type, Device } = data;
+    const pdiskData = [
+        { label: 'PDisk', value: getPDiskId({ NodeId, PDiskId }) || EMPTY_DATA_PLACEHOLDER },
+        { label: 'State', value: State || 'not available' },
+        { label: 'Type', value: Type || 'unknown' },
+    ];
+    if (NodeId) {
+        pdiskData.push({ label: 'Node Id', value: NodeId });
+    }
+    if (nodes && NodeId && nodes.get(NodeId)) {
+        pdiskData.push({ label: 'Host', value: nodes.get(NodeId) });
+    }
+    if (Path) {
+        pdiskData.push({ label: 'Path', value: Path });
+    }
+    pdiskData.push({
+        label: 'Available',
+        value: `${bytesToGB(AvailableSize)} of ${bytesToGB(TotalSize)}`,
+    });
+    if (Realtime && errorColors.includes(Realtime)) {
+        pdiskData.push({ label: 'Realtime', value: Realtime });
+    }
+    if (Device && errorColors.includes(Device)) {
+        pdiskData.push({ label: 'Device', value: Device });
+    }
+    return pdiskData;
+};
+export const PDiskPopup = ({ data, nodes, ...props }) => {
+    const info = React.useMemo(() => preparePDiskData(data, nodes), [data, nodes]);
+    return (_jsx(Popup, { contentClassName: b(), placement: ['top', 'bottom'], 
+        // bigger offset for easier switching to neighbour nodes
+        // matches the default offset for popup with arrow out of a sense of beauty
+        offset: [0, 12], ...props, children: _jsx(InfoViewer, { title: "PDisk", info: info, size: "s" }) }));
+};

package/dist/components/QueryResultTable/QueryResultTable.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import DataTable from '@gravity-ui/react-data-table';
+import { cn } from '../../utils/cn';
+import { DEFAULT_TABLE_SETTINGS } from '../../utils/constants';
+import { getColumnType, prepareQueryResponse } from '../../utils/query';
+import { isNumeric } from '../../utils/utils';
+import { ResizeableDataTable } from '../ResizeableDataTable/ResizeableDataTable';
+import { Cell } from './Cell';
+import i18n from './i18n';
+import './QueryResultTable.scss';
+const TABLE_SETTINGS = {
+    ...DEFAULT_TABLE_SETTINGS,
+    stripedRows: true,
+    dynamicRenderType: 'variable',
+    dynamicItemSizeGetter: () => 40,
+};
+export const b = cn('ydb-query-result-table');
+const prepareTypedColumns = (columns) => {
+    if (!columns.length) {
+        return [];
+    }
+    return columns.map(({ name, type }) => {
+        const columnType = getColumnType(type);
+        const column = {
+            name,
+            align: columnType === 'number' ? DataTable.RIGHT : DataTable.LEFT,
+            sortAccessor: (row) => {
+                const value = row[name];
+                if (value === undefined || value === null) {
+                    return null;
+                }
+                return columnType === 'number' ? BigInt(value) : value;
+            },
+            render: ({ row }) => _jsx(Cell, { value: String(row[name]) }),
+        };
+        return column;
+    });
+};
+const prepareGenericColumns = (data) => {
+    if (!data.length) {
+        return [];
+    }
+    return Object.keys(data[0]).map((name) => {
+        const column = {
+            name,
+            align: isNumeric(data[0][name]) ? DataTable.RIGHT : DataTable.LEFT,
+            sortAccessor: (row) => (isNumeric(row[name]) ? Number(row[name]) : row[name]),
+            render: ({ row }) => _jsx(Cell, { value: String(row[name]) }),
+        };
+        return column;
+    });
+};
+const getRowIndex = (_, index) => index;
+export const QueryResultTable = (props) => {
+    const { columns: rawColumns, data: rawData, settings: settingsMix, ...restProps } = props;
+    const data = React.useMemo(() => prepareQueryResponse(rawData), [rawData]);
+    const columns = React.useMemo(() => {
+        return rawColumns ? prepareTypedColumns(rawColumns) : prepareGenericColumns(data);
+    }, [data, rawColumns]);
+    const settings = React.useMemo(() => ({
+        ...TABLE_SETTINGS,
+        ...settingsMix,
+    }), [settingsMix]);
+    // empty data is expected to be be an empty array
+    // undefined data is not rendered at all
+    if (!Array.isArray(rawData)) {
+        return null;
+    }
+    if (!columns.length) {
+        return _jsx("div", { className: b('message'), children: i18n('empty') });
+    }
+    return (_jsx(ResizeableDataTable, { data: data, columns: columns, settings: settings, 
+        // prevent accessing row.id in case it is present but is not the PK (i.e. may repeat)
+        rowKey: getRowIndex, ...restProps }));
+};

package/dist/components/QueryResultTable/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "empty", params?: import("@gravity-ui/i18n").Params) => string;
+export default _default;

package/dist/components/ResizeableDataTable/ResizeableDataTable.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DataTable, { updateColumnsWidth } from '@gravity-ui/react-data-table';
+import { cn } from '../../utils/cn';
+import { useTableResize } from '../../utils/hooks/useTableResize';
+import './ResizeableDataTable.scss';
+const b = cn('ydb-resizeable-data-table');
+export function ResizeableDataTable({ columnsWidthLSKey, columns, settings, wrapperClassName, ...props }) {
+    const [tableColumnsWidth, setTableColumnsWidth] = useTableResize(columnsWidthLSKey);
+    const updatedColumns = updateColumnsWidth(columns, tableColumnsWidth);
+    const newSettings = {
+        ...settings,
+        defaultResizeable: true,
+    };
+    return (_jsx("div", { className: b(null, wrapperClassName), children: _jsx(DataTable, { theme: "yandex-cloud", columns: updatedColumns, onResize: setTableColumnsWidth, settings: newSettings, ...props }) }));
+}

package/dist/components/ShortyString/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "default_collapse_label" | "default_expand_label" | "chars_count", params?: import("@gravity-ui/i18n").Params) => string;
+export default _default;

package/dist/components/SpeedMultiMeter/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "averageSpeed" | "perMinute" | "perHour" | "perDay", params?: import("@gravity-ui/i18n").Params) => string;
+export default _default;

package/dist/components/TableWithControlsLayout/TableWithControlsLayout.d.ts

@@ -0,0 +1,14 @@
+import './TableWithControlsLayout.scss';
+interface TableWithControlsLayoutItemProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface TableProps extends TableWithControlsLayoutItemProps {
+    loading?: boolean;
+}
+export declare const TableWithControlsLayout: {
+    ({ children, className, }: TableWithControlsLayoutItemProps): import("react/jsx-runtime").JSX.Element;
+    Controls({ children, className, }: TableWithControlsLayoutItemProps): import("react/jsx-runtime").JSX.Element;
+    Table({ children, loading, className }: TableProps): import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/components/UsageLabel/UsageLabel.js

@@ -0,0 +1,8 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Label } from '@gravity-ui/uikit';
+import { cn } from '../../utils/cn';
+import './UsageLabel.scss';
+const b = cn('ydb-usage-label');
+export function UsageLabel({ value, overloadThreshold = 90, theme, ...props }) {
+    return (_jsxs(Label, { theme: theme, className: b({ overload: Number(value) >= overloadThreshold }), ...props, children: [value || 0, "%"] }));
+}

package/dist/components/VDiskInfo/VDiskInfo.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getVDiskPagePath } from '../../routes';
+import { valueIsDefined } from '../../utils';
+import { cn } from '../../utils/cn';
+import { formatStorageValuesToGb } from '../../utils/dataFormatters/dataFormatters';
+import { createVDiskDeveloperUILink } from '../../utils/developerUI/developerUI';
+import { bytesToSpeed } from '../../utils/utils';
+import { EntityStatus } from '../EntityStatus/EntityStatus';
+import { InfoViewer } from '../InfoViewer';
+import { LinkWithIcon } from '../LinkWithIcon/LinkWithIcon';
+import { ProgressViewer } from '../ProgressViewer/ProgressViewer';
+import { vDiskInfoKeyset } from './i18n';
+import './VDiskInfo.scss';
+const b = cn('ydb-vdisk-info');
+// eslint-disable-next-line complexity
+export function VDiskInfo({ data, isVDiskPage = false, ...infoViewerProps }) {
+    var _a, _b, _c, _d;
+    const { AllocatedSize, DiskSpace, FrontQueues, Guid, Replicated, VDiskState, VDiskSlotId, Kind, SatisfactionRank, AvailableSize, HasUnreadableBlobs, IncarnationGuid, InstanceGuid, StoragePoolName, ReadThroughput, WriteThroughput, PDiskId, NodeId, } = data;
+    const vdiskInfo = [];
+    if (valueIsDefined(VDiskSlotId)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('slot-id'), value: VDiskSlotId });
+    }
+    if (valueIsDefined(StoragePoolName)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('pool-name'), value: StoragePoolName });
+    }
+    if (valueIsDefined(VDiskState)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('state-status'),
+            value: VDiskState,
+        });
+    }
+    if (Number(AllocatedSize) >= 0 && Number(AvailableSize) >= 0) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('size'),
+            value: (_jsx(ProgressViewer, { value: AllocatedSize, capacity: Number(AllocatedSize) + Number(AvailableSize), formatValues: formatStorageValuesToGb, colorizeProgress: true })),
+        });
+    }
+    if (valueIsDefined(Kind)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('kind'), value: Kind });
+    }
+    if (valueIsDefined(Guid)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('guid'), value: Guid });
+    }
+    if (valueIsDefined(IncarnationGuid)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('incarnation-guid'), value: IncarnationGuid });
+    }
+    if (valueIsDefined(InstanceGuid)) {
+        vdiskInfo.push({ label: vDiskInfoKeyset('instance-guid'), value: InstanceGuid });
+    }
+    if (valueIsDefined(Replicated)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('replication-status'),
+            value: Replicated ? vDiskInfoKeyset('yes') : vDiskInfoKeyset('no'),
+        });
+    }
+    if (valueIsDefined(DiskSpace)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('space-status'),
+            value: _jsx(EntityStatus, { status: DiskSpace }),
+        });
+    }
+    if (valueIsDefined((_a = SatisfactionRank === null || SatisfactionRank === void 0 ? void 0 : SatisfactionRank.FreshRank) === null || _a === void 0 ? void 0 : _a.Flag)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('fresh-rank-satisfaction'),
+            value: _jsx(EntityStatus, { status: (_b = SatisfactionRank === null || SatisfactionRank === void 0 ? void 0 : SatisfactionRank.FreshRank) === null || _b === void 0 ? void 0 : _b.Flag }),
+        });
+    }
+    if (valueIsDefined((_c = SatisfactionRank === null || SatisfactionRank === void 0 ? void 0 : SatisfactionRank.LevelRank) === null || _c === void 0 ? void 0 : _c.Flag)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('level-rank-satisfaction'),
+            value: _jsx(EntityStatus, { status: (_d = SatisfactionRank === null || SatisfactionRank === void 0 ? void 0 : SatisfactionRank.LevelRank) === null || _d === void 0 ? void 0 : _d.Flag }),
+        });
+    }
+    if (valueIsDefined(FrontQueues)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('front-queues'),
+            value: _jsx(EntityStatus, { status: FrontQueues }),
+        });
+    }
+    if (valueIsDefined(HasUnreadableBlobs)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('has-unreadable-blobs'),
+            value: HasUnreadableBlobs ? vDiskInfoKeyset('yes') : vDiskInfoKeyset('no'),
+        });
+    }
+    if (valueIsDefined(ReadThroughput)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('read-throughput'),
+            value: bytesToSpeed(ReadThroughput),
+        });
+    }
+    if (valueIsDefined(WriteThroughput)) {
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('write-throughput'),
+            value: bytesToSpeed(WriteThroughput),
+        });
+    }
+    if (valueIsDefined(PDiskId) && valueIsDefined(NodeId) && valueIsDefined(VDiskSlotId)) {
+        const vDiskPagePath = getVDiskPagePath(VDiskSlotId, PDiskId, NodeId);
+        const vDiskInternalViewerPath = createVDiskDeveloperUILink({
+            nodeId: NodeId,
+            pDiskId: PDiskId,
+            vDiskSlotId: VDiskSlotId,
+        });
+        vdiskInfo.push({
+            label: vDiskInfoKeyset('links'),
+            value: (_jsxs("span", { className: b('links'), children: [!isVDiskPage && (_jsx(LinkWithIcon, { title: vDiskInfoKeyset('vdisk-page'), url: vDiskPagePath, external: false })), _jsx(LinkWithIcon, { title: vDiskInfoKeyset('developer-ui'), url: vDiskInternalViewerPath })] })),
+        });
+    }
+    return _jsx(InfoViewer, { info: vdiskInfo, ...infoViewerProps });
+}

package/dist/components/VDiskInfo/i18n/index.d.ts

@@ -0,0 +1 @@
+export declare const vDiskInfoKeyset: (key: "size" | "kind" | "yes" | "no" | "links" | "pool-name" | "guid" | "developer-ui" | "slot-id" | "incarnation-guid" | "instance-guid" | "replication-status" | "state-status" | "space-status" | "fresh-rank-satisfaction" | "level-rank-satisfaction" | "front-queues" | "has-unreadable-blobs" | "read-throughput" | "write-throughput" | "vdisk-page", params?: import("@gravity-ui/i18n").Params) => string;

package/dist/components/VDiskPopup/VDiskPopup.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Label, Popup } from '@gravity-ui/uikit';
+import { EFlag } from '../../types/api/enums';
+import { cn } from '../../utils/cn';
+import { EMPTY_DATA_PLACEHOLDER } from '../../utils/constants';
+import { stringifyVdiskId } from '../../utils/dataFormatters/dataFormatters';
+import { isFullVDiskData } from '../../utils/disks/helpers';
+import { bytesToGB, bytesToSpeed } from '../../utils/utils';
+import { InfoViewer } from '../InfoViewer';
+import { preparePDiskData } from '../PDiskPopup/PDiskPopup';
+import './VDiskPopup.scss';
+const b = cn('vdisk-storage-popup');
+const prepareUnavailableVDiskData = (data) => {
+    const { NodeId, PDiskId, VSlotId, StoragePoolName } = data;
+    const vdiskData = [{ label: 'State', value: 'not available' }];
+    if (StoragePoolName) {
+        vdiskData.push({ label: 'StoragePool', value: StoragePoolName });
+    }
+    vdiskData.push({ label: 'NodeId', value: NodeId !== null && NodeId !== void 0 ? NodeId : EMPTY_DATA_PLACEHOLDER }, { label: 'PDiskId', value: PDiskId !== null && PDiskId !== void 0 ? PDiskId : EMPTY_DATA_PLACEHOLDER }, { label: 'VSlotId', value: VSlotId !== null && VSlotId !== void 0 ? VSlotId : EMPTY_DATA_PLACEHOLDER });
+    return vdiskData;
+};
+const prepareVDiskData = (data) => {
+    var _a, _b, _c, _d, _e, _f;
+    const { VDiskId, VDiskState, SatisfactionRank, DiskSpace, FrontQueues, Replicated, UnsyncedVDisks, AllocatedSize, ReadThroughput, WriteThroughput, StoragePoolName, } = data;
+    const vdiskData = [
+        { label: 'VDisk', value: stringifyVdiskId(VDiskId) },
+        { label: 'State', value: VDiskState !== null && VDiskState !== void 0 ? VDiskState : 'not available' },
+    ];
+    if (StoragePoolName) {
+        vdiskData.push({ label: 'StoragePool', value: StoragePoolName });
+    }
+    if (SatisfactionRank && ((_a = SatisfactionRank.FreshRank) === null || _a === void 0 ? void 0 : _a.Flag) !== EFlag.Green) {
+        vdiskData.push({
+            label: 'Fresh',
+            value: (_b = SatisfactionRank.FreshRank) === null || _b === void 0 ? void 0 : _b.Flag,
+        });
+    }
+    if (SatisfactionRank && ((_c = SatisfactionRank.LevelRank) === null || _c === void 0 ? void 0 : _c.Flag) !== EFlag.Green) {
+        vdiskData.push({
+            label: 'Level',
+            value: (_d = SatisfactionRank.LevelRank) === null || _d === void 0 ? void 0 : _d.Flag,
+        });
+    }
+    if (SatisfactionRank && ((_e = SatisfactionRank.FreshRank) === null || _e === void 0 ? void 0 : _e.RankPercent)) {
+        vdiskData.push({
+            label: 'Fresh',
+            value: SatisfactionRank.FreshRank.RankPercent,
+        });
+    }
+    if (SatisfactionRank && ((_f = SatisfactionRank.LevelRank) === null || _f === void 0 ? void 0 : _f.RankPercent)) {
+        vdiskData.push({
+            label: 'Level',
+            value: SatisfactionRank.LevelRank.RankPercent,
+        });
+    }
+    if (DiskSpace && DiskSpace !== EFlag.Green) {
+        vdiskData.push({ label: 'Space', value: DiskSpace });
+    }
+    if (FrontQueues && FrontQueues !== EFlag.Green) {
+        vdiskData.push({ label: 'FrontQueues', value: FrontQueues });
+    }
+    if (!Replicated) {
+        vdiskData.push({ label: 'Replicated', value: 'NO' });
+    }
+    if (UnsyncedVDisks) {
+        vdiskData.push({ label: 'UnsyncVDisks', value: UnsyncedVDisks });
+    }
+    if (Number(AllocatedSize)) {
+        vdiskData.push({
+            label: 'Allocated',
+            value: bytesToGB(AllocatedSize),
+        });
+    }
+    if (Number(ReadThroughput)) {
+        vdiskData.push({ label: 'Read', value: bytesToSpeed(ReadThroughput) });
+    }
+    if (Number(WriteThroughput)) {
+        vdiskData.push({
+            label: 'Write',
+            value: bytesToSpeed(WriteThroughput),
+        });
+    }
+    return vdiskData;
+};
+export const VDiskPopup = ({ data, nodes, ...props }) => {
+    const isFullData = isFullVDiskData(data);
+    const vdiskInfo = React.useMemo(() => (isFullData ? prepareVDiskData(data) : prepareUnavailableVDiskData(data)), [data, isFullData]);
+    const pdiskInfo = React.useMemo(() => isFullData && data.PDisk && preparePDiskData(data.PDisk, nodes), [data, nodes, isFullData]);
+    return (_jsxs(Popup, { contentClassName: b(), placement: ['top', 'bottom'], 
+        // bigger offset for easier switching to neighbour nodes
+        // matches the default offset for popup with arrow out of a sense of beauty
+        offset: [0, 12], ...props, children: [data.DonorMode && _jsx(Label, { className: b('donor-label'), children: "Donor" }), _jsx(InfoViewer, { title: "VDisk", info: vdiskInfo, size: "s" }), pdiskInfo && _jsx(InfoViewer, { title: "PDisk", info: pdiskInfo, size: "s" })] }));
+};

package/dist/components/VirtualTable/ResizeableVirtualTable.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useTableResize } from '../../utils/hooks/useTableResize';
+import { VirtualTable } from './VirtualTable';
+function updateColumnsWidth(columns, columnsWidthSetup) {
+    return columns.map((column) => {
+        var _a;
+        return { ...column, width: (_a = columnsWidthSetup[column.name]) !== null && _a !== void 0 ? _a : column.width };
+    });
+}
+export function ResizeableVirtualTable({ columnsWidthLSKey, columns, ...props }) {
+    const [tableColumnsWidth, setTableColumnsWidth] = useTableResize(columnsWidthLSKey);
+    const updatedColumns = updateColumnsWidth(columns, tableColumnsWidth);
+    return (_jsx(VirtualTable, { columns: updatedColumns, onColumnsResize: setTableColumnsWidth, ...props }));
+}

package/dist/components/VirtualTable/TableRow.d.ts

@@ -0,0 +1,21 @@
+import type { Column, GetRowClassName } from './types';
+interface LoadingTableRowProps<T> {
+    columns: Column<T>[];
+    index: number;
+    height: number;
+}
+export declare const LoadingTableRow: <T>({ index, columns, height }: LoadingTableRowProps<T>) => import("react/jsx-runtime").JSX.Element;
+interface TableRowProps<T> {
+    columns: Column<T>[];
+    index: number;
+    row: T;
+    height: number;
+    getRowClassName?: GetRowClassName<T>;
+}
+export declare const TableRow: <T>({ row, index, columns, getRowClassName, height }: TableRowProps<T>) => import("react/jsx-runtime").JSX.Element;
+interface EmptyTableRowProps<T> {
+    columns: Column<T>[];
+    children?: React.ReactNode;
+}
+export declare const EmptyTableRow: <T>({ columns, children }: EmptyTableRowProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/VirtualTable/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "empty", params?: import("@gravity-ui/i18n").Params) => string;
+export default _default;

package/dist/components/VirtualTable/reducer.js

@@ -0,0 +1,103 @@
+const INIT_CHUNK = 'infiniteTable/INIT_CHUNK';
+const REMOVE_CHUNK = 'infiniteTable/REMOVE_CHUNK';
+const SET_CHUNK_LOADING = 'infiniteTable/SET_CHUNK_LOADING';
+const SET_CHUNK_DATA = 'infiniteTable/SET_CHUNK_DATA';
+const SET_CHUNK_ERROR = 'infiniteTable/SET_CHUNK_ERROR';
+const RESET_CHUNKS = 'infiniteTable/RESET_CHUNKS';
+export const setChunkData = (id, data) => {
+    return {
+        type: SET_CHUNK_DATA,
+        data: { id, data },
+    };
+};
+export const setChunkError = (id, error) => {
+    return {
+        type: SET_CHUNK_ERROR,
+        data: { id, error },
+    };
+};
+export const initChunk = (id) => {
+    return {
+        type: INIT_CHUNK,
+        data: { id },
+    };
+};
+export const setChunkLoading = (id) => {
+    return {
+        type: SET_CHUNK_LOADING,
+        data: { id },
+    };
+};
+export const removeChunk = (id) => {
+    return {
+        type: REMOVE_CHUNK,
+        data: { id },
+    };
+};
+export const resetChunks = () => {
+    return {
+        type: RESET_CHUNKS,
+    };
+};
+// Reducer wrapped in additional function to pass generic type
+export const createVirtualTableReducer = () => (state, action) => {
+    switch (action.type) {
+        case SET_CHUNK_DATA: {
+            const { id, data } = action.data;
+            return {
+                ...state,
+                [id]: {
+                    loading: false,
+                    wasLoaded: true,
+                    active: true,
+                    data,
+                },
+            };
+        }
+        case SET_CHUNK_ERROR: {
+            const { id, error } = action.data;
+            return {
+                ...state,
+                [id]: {
+                    loading: false,
+                    wasLoaded: true,
+                    active: true,
+                    error,
+                },
+            };
+        }
+        case INIT_CHUNK: {
+            const { id } = action.data;
+            return {
+                ...state,
+                [id]: {
+                    loading: false,
+                    wasLoaded: false,
+                    active: true,
+                },
+            };
+        }
+        case SET_CHUNK_LOADING: {
+            const { id } = action.data;
+            return {
+                ...state,
+                [id]: {
+                    loading: true,
+                    wasLoaded: false,
+                    active: true,
+                },
+            };
+        }
+        case REMOVE_CHUNK: {
+            const { id } = action.data;
+            const newState = { ...state };
+            delete newState[id];
+            return newState;
+        }
+        case RESET_CHUNKS: {
+            return {};
+        }
+        default:
+            return state;
+    }
+};

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

@@ -0,0 +1,52 @@
+import type { IResponseError } from '../../types/api/error';
+import type { ASCENDING, CENTER, DESCENDING, LEFT, RIGHT } from './constants';
+export interface Chunk<T> {
+    active: boolean;
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: T[];
+    error?: IResponseError;
+}
+export type GetChunk<T> = (id: number) => Chunk<T> | undefined;
+export type OnEntry = (id: string) => void;
+export type OnLeave = (id: string) => void;
+export type AlignType = typeof LEFT | typeof RIGHT | typeof CENTER;
+export type SortOrderType = typeof ASCENDING | typeof DESCENDING;
+export type SortParams = {
+    columnId?: string;
+    sortOrder?: SortOrderType;
+};
+export type OnSort = (params: SortParams) => void;
+export type HandleTableColumnsResize = (columnId: string, width: number) => void;
+export interface Column<T> {
+    name: string;
+    header?: React.ReactNode;
+    className?: string;
+    sortable?: boolean;
+    resizeable?: boolean;
+    render: (props: {
+        row: T;
+        index: number;
+    }) => React.ReactNode;
+    width: number;
+    resizeMaxWidth?: number;
+    resizeMinWidth?: number;
+    align: AlignType;
+}
+export interface VirtualTableData<T> {
+    data: T[];
+    total: number;
+    found: number;
+}
+export type FetchData<T> = (limit: number, offset: number, sortParams?: SortParams) => Promise<VirtualTableData<T>>;
+export type OnError = (error?: IResponseError) => void;
+interface ControlsParams {
+    totalEntities: number;
+    foundEntities: number;
+    inited: boolean;
+}
+export type RenderControls = (params: ControlsParams) => React.ReactNode;
+export type RenderEmptyDataMessage = () => React.ReactNode;
+export type RenderErrorMessage = (error: IResponseError) => React.ReactNode;
+export type GetRowClassName<T> = (row: T) => string | undefined;
+export {};

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

@@ -0,0 +1,16 @@
+export interface SlotComponent<Props = {}, Type = never> extends React.FC<Props & {
+    ref?: React.Ref<Type>;
+}> {
+}
+export interface SlotItem<Props = {}, Type = unknown> {
+    name: string;
+    props: Props;
+    ref?: React.Ref<Type>;
+    rendered: ExtractChildrenType<Props>;
+}
+type ExtractChildrenType<Props> = Props extends {
+    children: infer Children;
+} ? Children : Props extends {
+    children?: infer Children;
+} ? Children | undefined : never;
+export {};

package/dist/containers/App/App.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { Store } from '@reduxjs/toolkit';
+import type { History } from 'history';
+import type { YDBEmbeddedUISettings } from '../UserSettings/settings';
+import './App.scss';
+export interface AppProps {
+    store: Store;
+    history: History;
+    singleClusterMode: boolean;
+    userSettings?: YDBEmbeddedUISettings;
+    children?: React.ReactNode;
+}
+declare function App({ store, history, singleClusterMode, children, userSettings }: AppProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react-redux").ConnectedComponent<typeof App, {
+    history: History;
+    userSettings?: YDBEmbeddedUISettings;
+    store: Store;
+    children?: React.ReactNode;
+    context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null>;
+}>;
+export default _default;

package/dist/containers/App/Content.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import './App.scss';
+interface ContentProps {
+    singleClusterMode: boolean;
+    children: React.ReactNode;
+}
+export declare function Content(props: ContentProps): import("react/jsx-runtime").JSX.Element;
+interface ContentWrapperProps {
+    singleClusterMode: boolean;
+    isAuthenticated: boolean;
+    children: React.ReactNode;
+}
+declare function ContentWrapper(props: ContentWrapperProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: import("react-redux").ConnectedComponent<typeof ContentWrapper, {
+    children: React.ReactNode;
+    context?: React.Context<import("react-redux").ReactReduxContextValue<any, import("redux").UnknownAction> | null>;
+    store?: import("redux").Store;
+}>;
+export default _default;