@gravity-ui/dashkit 3.0.1

package/build/esm/components/OverlayControls/OverlayControls.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import { ButtonView, ButtonSize, IconProps, MenuItemProps } from '@gravity-ui/uikit';
+import { ConfigItem, PluginBase } from '../../shared';
+import './OverlayControls.css';
+export declare enum OverlayControlsPosition {
+    TopRight = "top_right",
+    TopLeft = "top_left",
+    BottomRight = "bottom_right",
+    BottomLeft = "bottom_left"
+}
+export interface OverlayControlItem {
+    title?: string;
+    icon?: IconProps['data'];
+    iconSize?: number | string;
+    handler?: (item: ConfigItem) => void;
+    allWidgetsControls?: boolean;
+    excludeWidgetsTypes?: Array<PluginBase['type']>;
+    id?: string;
+}
+export interface OverlayCustomControlItem {
+    id: string;
+    title?: string;
+    icon?: MenuItemProps['icon'];
+    iconSize?: number | string;
+    handler?: (item: ConfigItem) => void;
+    visible?: (item: ConfigItem) => boolean;
+    className?: string;
+}
+interface OverlayControlsDefaultProps {
+    position: OverlayControlsPosition;
+    view: ButtonView;
+    size: ButtonSize;
+}
+interface OverlayControlsProps extends OverlayControlsDefaultProps {
+    configItem: ConfigItem;
+    items?: OverlayControlItem[];
+}
+declare class OverlayControls extends React.Component<OverlayControlsProps> {
+    static contextType: React.Context<any>;
+    static defaultProps: OverlayControlsDefaultProps;
+    render(): JSX.Element;
+    private renderControlsItem;
+    private getDropDownMenuItemConfig;
+    private renderControls;
+    private renderMenu;
+    private isDefaultMenu;
+    private renderDropdownMenu;
+    private getCustomLeftOverlayControls;
+    private onCopyItem;
+    private onEditItem;
+    private onRemoveItem;
+    private getControlItemPinStyle;
+    private getCustomControlsWithWidgets;
+}
+export default OverlayControls;

package/build/esm/components/OverlayControls/OverlayControls.js

@@ -0,0 +1,209 @@
+import React from 'react';
+import block from 'bem-cn-lite';
+import i18n from '../../i18n';
+import noop from 'lodash/noop';
+import { DashKitContext } from '../../context/DashKitContext';
+import { Icon, DropdownMenu, Button, } from '@gravity-ui/uikit';
+import { COPIED_WIDGET_STORE_KEY, MenuItems } from '../../constants';
+import { DotsIcon } from '../../icons/DotsIcon';
+import { CogIcon } from '../../icons/CogIcon';
+import { CloseIcon } from '../../icons/CloseIcon';
+import './OverlayControls.css';
+const b = block('dashkit-overlay-controls');
+export var OverlayControlsPosition;
+(function (OverlayControlsPosition) {
+    OverlayControlsPosition["TopRight"] = "top_right";
+    OverlayControlsPosition["TopLeft"] = "top_left";
+    OverlayControlsPosition["BottomRight"] = "bottom_right";
+    OverlayControlsPosition["BottomLeft"] = "bottom_left";
+})(OverlayControlsPosition || (OverlayControlsPosition = {}));
+const DEFAULT_DROPDOWN_MENU = [MenuItems.Copy, MenuItems.Delete];
+class OverlayControls extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.renderControlsItem = (item, index, length) => {
+            const { view, size } = this.props;
+            const { title, handler, icon, iconSize } = item;
+            const onItemClickHandler = typeof handler === 'function' ? handler : noop;
+            return (React.createElement(Button, { key: index, view: view, size: size, title: title, pin: this.getControlItemPinStyle(index, length), onClick: () => onItemClickHandler(this.props.configItem) },
+                React.createElement(Icon, { data: icon || CogIcon, size: icon ? iconSize : 24 })));
+        };
+        this.getCustomLeftOverlayControls = () => {
+            // выбираем только items-ы у которых проставлено поле `allWidgetsControls:true`
+            // те контролы, которые будут показываться слева от меню
+            let controls = [];
+            for (const controlItem of Object.values(this.context.overlayControls || {})) {
+                controls = controls.concat((controlItem.filter((item) => {
+                    var _a;
+                    // если тип виджета-плагина в списке исключаемых, то не показываем такой контрол
+                    if ((_a = item.excludeWidgetsTypes) === null || _a === void 0 ? void 0 : _a.includes(this.props.configItem.type)) {
+                        return false;
+                    }
+                    return item.allWidgetsControls;
+                }) || []).map((item) => {
+                    var _a;
+                    if (!(item === null || item === void 0 ? void 0 : item.id)) {
+                        return item;
+                    }
+                    return Object.assign(Object.assign({}, item), { handler: typeof item.handler === 'function'
+                            ? item.handler
+                            : ((_a = this.getDropDownMenuItemConfig(item.id)) === null || _a === void 0 ? void 0 : _a.action) || (() => { }) });
+                }));
+            }
+            return controls;
+        };
+        this.onCopyItem = () => {
+            const correspondedItemLayout = this.context.config.layout.find((item) => {
+                return item.i === this.props.configItem.id;
+            });
+            const options = {
+                timestamp: Date.now(),
+                data: this.props.configItem.data,
+                type: this.props.configItem.type,
+                defaults: this.props.configItem.defaults,
+                namespace: this.props.configItem.namespace,
+                layout: {
+                    w: correspondedItemLayout.w,
+                    h: correspondedItemLayout.h,
+                },
+            };
+            localStorage.setItem(COPIED_WIDGET_STORE_KEY, JSON.stringify(options));
+        };
+        this.onEditItem = () => {
+            this.context.editItem(this.props.configItem);
+        };
+        this.onRemoveItem = () => {
+            const { id } = this.props.configItem;
+            this.context.removeItem(id);
+        };
+    }
+    render() {
+        const { items = [], position } = this.props;
+        const hasCustomControlsWithWidgets = items.length > 0;
+        const controls = hasCustomControlsWithWidgets
+            ? this.getCustomControlsWithWidgets()
+            : this.renderControls();
+        return React.createElement("div", { className: b({ position }) }, controls);
+    }
+    getDropDownMenuItemConfig(menuName, isDefaultMenu) {
+        switch (menuName) {
+            case MenuItems.Copy: {
+                return {
+                    action: this.onCopyItem,
+                    text: i18n('label_copy'),
+                };
+            }
+            case MenuItems.Delete: {
+                return {
+                    action: this.onRemoveItem,
+                    text: i18n('label_delete'),
+                };
+            }
+            case MenuItems.Settings: {
+                // для дефолтного состояния меню нет настройки settings, а для кастомного можно использовать дефолтный action и text
+                if (isDefaultMenu) {
+                    return null;
+                }
+                return {
+                    action: this.onEditItem,
+                    text: i18n('label_settings'),
+                };
+            }
+        }
+        return null;
+    }
+    renderControls() {
+        const { view, size } = this.props;
+        const customLeftControls = this.getCustomLeftOverlayControls();
+        const hasCustomOverlayLeftControls = Boolean(customLeftControls.length);
+        const defaultControl = (React.createElement(Button, { view: view, size: size, title: i18n('label_settings'), pin: "round-brick", onClick: this.onEditItem, qa: "dashkit-overlay-control-settings" },
+            React.createElement(Icon, { data: CogIcon, size: "24" })));
+        const controls = hasCustomOverlayLeftControls
+            ? customLeftControls.map((item, index, items) => this.renderControlsItem(item, index, items.length + 1))
+            : defaultControl;
+        const menu = this.renderMenu();
+        return (React.createElement("div", { className: b('default-controls', {
+                'with-custom-left': hasCustomOverlayLeftControls,
+            }) },
+            controls,
+            menu));
+    }
+    renderMenu() {
+        const { view, size } = this.props;
+        const { registerManager } = this.context;
+        const withMenu = Array.isArray(registerManager.settings.menu) && registerManager.settings.menu.length;
+        return (React.createElement(React.Fragment, null, withMenu ? (this.renderDropdownMenu()) : (React.createElement(Button, { view: view, size: size, title: i18n('label_delete'), pin: "brick-round", onClick: this.onRemoveItem, qa: "dashkit-overlay-control-menu" },
+            React.createElement(Icon, { data: CloseIcon, size: "12" })))));
+    }
+    isDefaultMenu(menu) {
+        return menu === null || menu === void 0 ? void 0 : menu.every((item) => Object.values(MenuItems).includes(String(item)));
+    }
+    renderDropdownMenu() {
+        const { view, size } = this.props;
+        const { registerManager } = this.context;
+        let menu = registerManager.settings.menu;
+        if (!menu.length) {
+            menu = DEFAULT_DROPDOWN_MENU;
+        }
+        const isDefaultMenu = this.isDefaultMenu(menu);
+        let items = isDefaultMenu
+            ? (menu || []).map((name) => this.getDropDownMenuItemConfig(name, true))
+            : menu.map((item) => {
+                var _a;
+                if (typeof item === 'string') {
+                    return null;
+                }
+                // custom menu dropdown item filter
+                if (item.visible && !item.visible(this.props.configItem)) {
+                    return null;
+                }
+                const itemHandler = item.handler;
+                const itemAction = typeof itemHandler === 'function'
+                    ? () => itemHandler(this.props.configItem)
+                    : ((_a = this.getDropDownMenuItemConfig(item.id)) === null || _a === void 0 ? void 0 : _a.action) || (() => { });
+                return {
+                    text: item.title || i18n(item.id),
+                    icon: item.icon,
+                    action: itemAction,
+                    className: item.className,
+                };
+            });
+        items = items.filter(Boolean);
+        return (React.createElement(DropdownMenu, { items: items, switcher: React.createElement(Button, { view: view, size: size, pin: "brick-round" },
+                React.createElement(Icon, { data: DotsIcon, size: "16" })) }));
+    }
+    getControlItemPinStyle(index, itemsLength) {
+        const isOnlyOneItem = itemsLength === 1;
+        const isFirstItem = index === 0;
+        const isLastItem = index === itemsLength - 1;
+        if (isOnlyOneItem) {
+            return 'round-round';
+        }
+        if (isFirstItem) {
+            return 'round-brick';
+        }
+        if (isLastItem) {
+            return 'brick-round';
+        }
+        return 'brick-brick';
+    }
+    getCustomControlsWithWidgets() {
+        // Добавляем контрол удаления виджета по умолчанию
+        const deleteControl = {
+            title: i18n('label_delete'),
+            icon: CloseIcon,
+            iconSize: 12,
+            handler: this.onRemoveItem,
+        };
+        const { items = [] } = this.props;
+        const customOverlayControls = [...items, deleteControl];
+        return customOverlayControls.map((item, index, controlItems) => this.renderControlsItem(item, index, controlItems.length));
+    }
+}
+OverlayControls.contextType = DashKitContext;
+OverlayControls.defaultProps = {
+    position: OverlayControlsPosition.TopRight,
+    view: 'normal',
+    size: 'm',
+};
+export default OverlayControls;

package/build/esm/components/index.d.ts

@@ -0,0 +1 @@
+export * from './DashKit';

package/build/esm/components/index.js

@@ -0,0 +1 @@
+export * from './DashKit';

package/build/esm/constants/common.d.ts

@@ -0,0 +1,7 @@
+export declare const COPIED_WIDGET_STORE_KEY = "dashCopiedItem";
+export declare const DEFAULT_NAMESPACE = "default";
+export declare const MenuItems: {
+    readonly Copy: "copy";
+    readonly Delete: "delete";
+    readonly Settings: "settings";
+};

package/build/esm/constants/common.js

@@ -0,0 +1,7 @@
+export const COPIED_WIDGET_STORE_KEY = 'dashCopiedItem';
+export const DEFAULT_NAMESPACE = 'default';
+export const MenuItems = {
+    Copy: 'copy',
+    Delete: 'delete',
+    Settings: 'settings',
+};

package/build/esm/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './common';

package/build/esm/constants/index.js

@@ -0,0 +1 @@
+export * from './common';

package/build/esm/context/DashKitContext.d.ts

@@ -0,0 +1,2 @@
+export const DashKitContext: React.Context<any>;
+import React from "react";

package/build/esm/context/DashKitContext.js

@@ -0,0 +1,3 @@
+import React from 'react';
+const DashKitContext = React.createContext();
+export { DashKitContext };

package/build/esm/hocs/prepareItem.d.ts

@@ -0,0 +1,66 @@
+export function prepareItem(Component: any): {
+    new (props: any): {
+        shouldComponentUpdate(nextProps: any): boolean;
+        _onStateAndParamsChange: (stateAndParams: any) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<any>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    new (props: any, context: any): {
+        shouldComponentUpdate(nextProps: any): boolean;
+        _onStateAndParamsChange: (stateAndParams: any) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<any>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    propTypes: {
+        adjustWidgetLayout: PropTypes.Validator<(...args: any[]) => any>;
+        layout: PropTypes.Requireable<any[]>;
+        id: PropTypes.Requireable<string>;
+        item: PropTypes.Requireable<object>;
+        shouldItemUpdate: PropTypes.Requireable<boolean>;
+        width: PropTypes.Requireable<number>;
+        height: PropTypes.Requireable<number>;
+        transform: PropTypes.Requireable<string>;
+        forwardedPluginRef: PropTypes.Requireable<any>;
+    };
+    contextType: React.Context<any>;
+};

package/build/esm/hocs/prepareItem.js

@@ -0,0 +1,61 @@
+import React from 'react';
+import { DashKitContext } from '../context/DashKitContext';
+import PropTypes from 'prop-types';
+export function prepareItem(Component) {
+    var _a;
+    return _a = class PrepareItem extends React.Component {
+            constructor() {
+                super(...arguments);
+                this._onStateAndParamsChange = (stateAndParams) => {
+                    this.context.onItemStateAndParamsChange(this.props.id, stateAndParams);
+                };
+            }
+            shouldComponentUpdate(nextProps) {
+                const { width, height, transform } = this.props;
+                const { width: widthNext, height: heightNext, transform: transformNext } = nextProps;
+                if (!nextProps.shouldItemUpdate &&
+                    width === widthNext &&
+                    height === heightNext &&
+                    transform === transformNext) {
+                    return false;
+                }
+                return true;
+            }
+            render() {
+                const { id, width, height, item, adjustWidgetLayout, layout } = this.props;
+                const { itemsState, itemsParams, registerManager, settings, context, editMode } = this.context;
+                const { type, data, defaults, namespace } = item;
+                const rendererProps = {
+                    data,
+                    editMode,
+                    params: itemsParams[id],
+                    state: itemsState[id],
+                    onStateAndParamsChange: this._onStateAndParamsChange,
+                    width,
+                    height,
+                    id,
+                    defaults,
+                    namespace,
+                    settings,
+                    context,
+                    layout,
+                    gridLayout: registerManager.gridLayout,
+                    adjustWidgetLayout,
+                };
+                return (React.createElement(Component, { forwardedPluginRef: this.props.forwardedPluginRef, rendererProps: rendererProps, registerManager: registerManager, type: type }));
+            }
+        },
+        _a.propTypes = {
+            adjustWidgetLayout: PropTypes.func.isRequired,
+            layout: PropTypes.array,
+            id: PropTypes.string,
+            item: PropTypes.object,
+            shouldItemUpdate: PropTypes.bool,
+            width: PropTypes.number,
+            height: PropTypes.number,
+            transform: PropTypes.string,
+            forwardedPluginRef: PropTypes.any,
+        },
+        _a.contextType = DashKitContext,
+        _a;
+}

package/build/esm/hocs/withContext.d.ts

@@ -0,0 +1,165 @@
+export function withContext(Component: any): {
+    new (props: any): {
+        state: {
+            currentLayout: any;
+        };
+        originalLayouts: {};
+        adjustedLayouts: {};
+        _onChange({ config, itemsStateAndParams, }: {
+            config?: any;
+            itemsStateAndParams?: any;
+        }): void;
+        _onLayoutChange: (layout: any) => void;
+        _onItemRemove: (id: any) => void;
+        _onItemEdit: (configItem: any) => void;
+        _onItemStateAndParamsChange: (id: any, stateAndParams: any) => void;
+        _memorizeOriginalLayout: (widgetId: any, preAutoHeightLayout: any, postAutoHeightLayout: any) => void;
+        _revertToOriginalLayout: (widgetId: any) => void;
+        readonly _itemsParams: {
+            [x: string]: import("../shared").StringParams;
+        };
+        readonly _itemsState: Record<string, import("../shared").ItemState>;
+        _getItemsMeta: (pluginsRefs: any) => any;
+        _getLayout: () => any;
+        _reloadItems: (pluginsRefs: any, data: any) => void;
+        readonly _contextValue: {
+            getLayout: () => any;
+            config: any;
+            context: any;
+            overlayControls: any;
+            noOverlay: any;
+            defaultGlobalParams: any;
+            globalParams: any;
+            editMode: any;
+            settings: any;
+            itemsState: Record<string, import("../shared").ItemState>;
+            itemsParams: {
+                [x: string]: import("../shared").StringParams;
+            };
+            registerManager: any;
+            onItemStateAndParamsChange: (id: any, stateAndParams: any) => void;
+            removeItem: (id: any) => void;
+            editItem: (configItem: any) => void;
+            layoutChange: (layout: any) => void;
+            getItemsMeta: (pluginsRefs: any) => any;
+            reloadItems: (pluginsRefs: any, data: any) => void;
+            memorizeOriginalLayout: (widgetId: any, preAutoHeightLayout: any, postAutoHeightLayout: any) => void;
+            revertToOriginalLayout: (widgetId: any) => void;
+            forwardedMetaRef: any;
+            draggableHandleClassName: any;
+        };
+        render(): JSX.Element;
+        context: any;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    new (props: any, context: any): {
+        state: {
+            currentLayout: any;
+        };
+        originalLayouts: {};
+        adjustedLayouts: {};
+        _onChange({ config, itemsStateAndParams, }: {
+            config?: any;
+            itemsStateAndParams?: any;
+        }): void;
+        _onLayoutChange: (layout: any) => void;
+        _onItemRemove: (id: any) => void;
+        _onItemEdit: (configItem: any) => void;
+        _onItemStateAndParamsChange: (id: any, stateAndParams: any) => void;
+        _memorizeOriginalLayout: (widgetId: any, preAutoHeightLayout: any, postAutoHeightLayout: any) => void;
+        _revertToOriginalLayout: (widgetId: any) => void;
+        readonly _itemsParams: {
+            [x: string]: import("../shared").StringParams;
+        };
+        readonly _itemsState: Record<string, import("../shared").ItemState>;
+        _getItemsMeta: (pluginsRefs: any) => any;
+        _getLayout: () => any;
+        _reloadItems: (pluginsRefs: any, data: any) => void;
+        readonly _contextValue: {
+            getLayout: () => any;
+            config: any;
+            context: any;
+            overlayControls: any;
+            noOverlay: any;
+            defaultGlobalParams: any;
+            globalParams: any;
+            editMode: any;
+            settings: any;
+            itemsState: Record<string, import("../shared").ItemState>;
+            itemsParams: {
+                [x: string]: import("../shared").StringParams;
+            };
+            registerManager: any;
+            onItemStateAndParamsChange: (id: any, stateAndParams: any) => void;
+            removeItem: (id: any) => void;
+            editItem: (configItem: any) => void;
+            layoutChange: (layout: any) => void;
+            getItemsMeta: (pluginsRefs: any) => any;
+            reloadItems: (pluginsRefs: any, data: any) => void;
+            memorizeOriginalLayout: (widgetId: any, preAutoHeightLayout: any, postAutoHeightLayout: any) => void;
+            revertToOriginalLayout: (widgetId: any) => void;
+            forwardedMetaRef: any;
+            draggableHandleClassName: any;
+        };
+        render(): JSX.Element;
+        context: any;
+        setState<K extends string | number | symbol>(state: any, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<any>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<any>, nextContext: any): void;
+    };
+    propTypes: {
+        editMode: PropTypes.Requireable<boolean>;
+        context: PropTypes.Requireable<object>;
+        overlayControls: PropTypes.Requireable<object>;
+        config: PropTypes.Requireable<object>;
+        onItemEdit: PropTypes.Requireable<(...args: any[]) => any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        defaultGlobalParams: PropTypes.Requireable<object>;
+        globalParams: PropTypes.Requireable<object>;
+        itemsStateAndParams: PropTypes.Requireable<object>;
+        registerManager: PropTypes.Requireable<object>;
+        layout: PropTypes.Requireable<any[]>;
+        settings: PropTypes.Requireable<object>;
+        forwardedMetaRef: PropTypes.Requireable<object>;
+        noOverlay: PropTypes.Requireable<boolean>;
+        draggableHandleClassName: PropTypes.Requireable<string>;
+        _EXPERIMENTAL_preventDoubleCompact: PropTypes.Requireable<boolean>;
+    };
+    contextType?: React.Context<any> | undefined;
+};