@gravity-ui/dashkit 3.0.1

package/build/cjs/components/OverlayControls/OverlayControls.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayControlsPosition = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const bem_cn_lite_1 = tslib_1.__importDefault(require("bem-cn-lite"));
+const i18n_1 = tslib_1.__importDefault(require("../../i18n"));
+const noop_1 = tslib_1.__importDefault(require("lodash/noop"));
+const DashKitContext_1 = require("../../context/DashKitContext");
+const uikit_1 = require("@gravity-ui/uikit");
+const constants_1 = require("../../constants");
+const DotsIcon_1 = require("../../icons/DotsIcon");
+const CogIcon_1 = require("../../icons/CogIcon");
+const CloseIcon_1 = require("../../icons/CloseIcon");
+const b = (0, bem_cn_lite_1.default)('dashkit-overlay-controls');
+var OverlayControlsPosition;
+(function (OverlayControlsPosition) {
+    OverlayControlsPosition["TopRight"] = "top_right";
+    OverlayControlsPosition["TopLeft"] = "top_left";
+    OverlayControlsPosition["BottomRight"] = "bottom_right";
+    OverlayControlsPosition["BottomLeft"] = "bottom_left";
+})(OverlayControlsPosition = exports.OverlayControlsPosition || (exports.OverlayControlsPosition = {}));
+const DEFAULT_DROPDOWN_MENU = [constants_1.MenuItems.Copy, constants_1.MenuItems.Delete];
+class OverlayControls extends react_1.default.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_1.default;
+            return (react_1.default.createElement(uikit_1.Button, { key: index, view: view, size: size, title: title, pin: this.getControlItemPinStyle(index, length), onClick: () => onItemClickHandler(this.props.configItem) },
+                react_1.default.createElement(uikit_1.Icon, { data: icon || CogIcon_1.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(constants_1.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_1.default.createElement("div", { className: b({ position }) }, controls);
+    }
+    getDropDownMenuItemConfig(menuName, isDefaultMenu) {
+        switch (menuName) {
+            case constants_1.MenuItems.Copy: {
+                return {
+                    action: this.onCopyItem,
+                    text: (0, i18n_1.default)('label_copy'),
+                };
+            }
+            case constants_1.MenuItems.Delete: {
+                return {
+                    action: this.onRemoveItem,
+                    text: (0, i18n_1.default)('label_delete'),
+                };
+            }
+            case constants_1.MenuItems.Settings: {
+                // для дефолтного состояния меню нет настройки settings, а для кастомного можно использовать дефолтный action и text
+                if (isDefaultMenu) {
+                    return null;
+                }
+                return {
+                    action: this.onEditItem,
+                    text: (0, i18n_1.default)('label_settings'),
+                };
+            }
+        }
+        return null;
+    }
+    renderControls() {
+        const { view, size } = this.props;
+        const customLeftControls = this.getCustomLeftOverlayControls();
+        const hasCustomOverlayLeftControls = Boolean(customLeftControls.length);
+        const defaultControl = (react_1.default.createElement(uikit_1.Button, { view: view, size: size, title: (0, i18n_1.default)('label_settings'), pin: "round-brick", onClick: this.onEditItem, qa: "dashkit-overlay-control-settings" },
+            react_1.default.createElement(uikit_1.Icon, { data: CogIcon_1.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_1.default.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_1.default.createElement(react_1.default.Fragment, null, withMenu ? (this.renderDropdownMenu()) : (react_1.default.createElement(uikit_1.Button, { view: view, size: size, title: (0, i18n_1.default)('label_delete'), pin: "brick-round", onClick: this.onRemoveItem, qa: "dashkit-overlay-control-menu" },
+            react_1.default.createElement(uikit_1.Icon, { data: CloseIcon_1.CloseIcon, size: "12" })))));
+    }
+    isDefaultMenu(menu) {
+        return menu === null || menu === void 0 ? void 0 : menu.every((item) => Object.values(constants_1.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 || (0, i18n_1.default)(item.id),
+                    icon: item.icon,
+                    action: itemAction,
+                    className: item.className,
+                };
+            });
+        items = items.filter(Boolean);
+        return (react_1.default.createElement(uikit_1.DropdownMenu, { items: items, switcher: react_1.default.createElement(uikit_1.Button, { view: view, size: size, pin: "brick-round" },
+                react_1.default.createElement(uikit_1.Icon, { data: DotsIcon_1.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: (0, i18n_1.default)('label_delete'),
+            icon: CloseIcon_1.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_1.DashKitContext;
+OverlayControls.defaultProps = {
+    position: OverlayControlsPosition.TopRight,
+    view: 'normal',
+    size: 'm',
+};
+exports.default = OverlayControls;

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

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

package/build/cjs/components/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DashKit"), exports);

package/build/cjs/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/cjs/constants/common.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuItems = exports.DEFAULT_NAMESPACE = exports.COPIED_WIDGET_STORE_KEY = void 0;
+exports.COPIED_WIDGET_STORE_KEY = 'dashCopiedItem';
+exports.DEFAULT_NAMESPACE = 'default';
+exports.MenuItems = {
+    Copy: 'copy',
+    Delete: 'delete',
+    Settings: 'settings',
+};

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

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

package/build/cjs/constants/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./common"), exports);

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

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

package/build/cjs/context/DashKitContext.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashKitContext = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const DashKitContext = react_1.default.createContext();
+exports.DashKitContext = DashKitContext;

package/build/cjs/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/cjs/hocs/prepareItem.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareItem = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const DashKitContext_1 = require("../context/DashKitContext");
+const prop_types_1 = tslib_1.__importDefault(require("prop-types"));
+function prepareItem(Component) {
+    var _a;
+    return _a = class PrepareItem extends react_1.default.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_1.default.createElement(Component, { forwardedPluginRef: this.props.forwardedPluginRef, rendererProps: rendererProps, registerManager: registerManager, type: type }));
+            }
+        },
+        _a.propTypes = {
+            adjustWidgetLayout: prop_types_1.default.func.isRequired,
+            layout: prop_types_1.default.array,
+            id: prop_types_1.default.string,
+            item: prop_types_1.default.object,
+            shouldItemUpdate: prop_types_1.default.bool,
+            width: prop_types_1.default.number,
+            height: prop_types_1.default.number,
+            transform: prop_types_1.default.string,
+            forwardedPluginRef: prop_types_1.default.any,
+        },
+        _a.contextType = DashKitContext_1.DashKitContext,
+        _a;
+}
+exports.prepareItem = prepareItem;

package/build/cjs/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;
+};