@gravity-ui/dashkit 3.0.1

package/build/cjs/typings/common.d.ts

@@ -0,0 +1,32 @@
+import { OverlayCustomControlItem } from '../components/OverlayControls/OverlayControls';
+import { MenuItems } from '../constants';
+export interface Settings {
+    gridLayout?: {
+        margin?: [number, number];
+        rowHeight?: number;
+        cols?: number;
+        containerPadding?: [number, number];
+    };
+    theme?: string;
+    isMobile?: boolean;
+    menu?: Array<MenuItem>;
+}
+export declare type MenuItem = typeof MenuItems[keyof typeof MenuItems] | OverlayCustomControlItem;
+export interface SettingsProps {
+    autoupdateInterval: number;
+    silentLoading: boolean;
+}
+export interface ContextProps {
+    [key: string]: any;
+}
+export interface WidgetLayout {
+    i: string;
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+    minW: number;
+    minH: number;
+    maxW?: number;
+    maxH?: number;
+}

package/build/cjs/typings/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/typings/config.d.ts

@@ -0,0 +1,7 @@
+import { ConfigItem, ConfigLayout } from '../shared';
+export interface AddConfigItem extends Omit<ConfigItem, 'id' | 'namespace'> {
+    id?: null;
+    namespace?: string;
+    layout?: ConfigLayout;
+}
+export declare type SetConfigItem = ConfigItem | AddConfigItem;

package/build/cjs/typings/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/typings/global.d.ts

@@ -0,0 +1,7 @@
+declare module '*.svg' {
+    const content: SVGIconData;
+
+    export default content;
+}
+
+declare module '*.md';

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

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

package/build/cjs/typings/index.js

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

package/build/cjs/typings/plugin.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { ContextProps, SettingsProps, WidgetLayout } from './common';
+import { StringParams, ConfigItem, ItemState, ItemStateAndParams, PluginBase } from '../shared';
+import { RegisterManagerGridLayout } from '../utils/register-manager';
+export interface PluginWidgetProps {
+    id: string;
+    editMode: boolean;
+    params: StringParams;
+    state: ItemState;
+    onStateAndParamsChange: (stateAndParams: ItemStateAndParams) => void;
+    width: number;
+    height: number;
+    data: ConfigItem['data'];
+    defaults: ConfigItem['defaults'];
+    namespace: ConfigItem['namespace'];
+    settings: SettingsProps;
+    context: ContextProps;
+    layout: WidgetLayout[];
+    gridLayout: RegisterManagerGridLayout;
+    adjustWidgetLayout: (data: {
+        widgetId: string;
+        needSetDefault?: boolean;
+        adjustedWidgetLayout?: WidgetLayout;
+    }) => void;
+}
+export interface PluginDefaultLayout {
+    w?: number;
+    h?: number;
+    x?: number;
+    y?: number;
+    minW?: number;
+    maxW?: number;
+    minH?: number;
+    maxH?: number;
+}
+export interface Plugin<P extends PluginWidgetProps = any> extends PluginBase {
+    defaultLayout?: PluginDefaultLayout;
+    renderer: (props: P, forwardedRef: React.RefObject<any>) => React.ReactNode;
+}

package/build/cjs/typings/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/utils/__tests__/mock.test.d.ts

@@ -0,0 +1 @@
+

package/build/cjs/utils/__tests__/mock.test.js

@@ -0,0 +1,8 @@
+"use strict";
+describe('test: mock', () => {
+    describe('mock', () => {
+        test('adds 1 + 2 to equal 3', () => {
+            expect(1 + 2).toBe(3);
+        });
+    });
+});

package/build/cjs/utils/configure.d.ts

@@ -0,0 +1,9 @@
+export declare type Lang = 'ru' | 'en';
+interface Config {
+    lang?: Lang;
+}
+declare type Subscriber = (config: Config) => void;
+export declare const configure: (newConfig: Config) => void;
+export declare const subscribeConfigure: (sub: Subscriber) => () => void;
+export declare const getConfig: () => Config;
+export {};

package/build/cjs/utils/configure.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = exports.subscribeConfigure = exports.configure = void 0;
+let subs = [];
+const config = {};
+const configure = (newConfig) => {
+    Object.assign(config, newConfig);
+    subs.forEach((sub) => {
+        sub(config);
+    });
+};
+exports.configure = configure;
+const subscribeConfigure = (sub) => {
+    subs.push(sub);
+    return () => {
+        subs = subs.filter((item) => item !== sub);
+    };
+};
+exports.subscribeConfigure = subscribeConfigure;
+const getConfig = () => config;
+exports.getConfig = getConfig;

package/build/cjs/utils/i18n.d.ts

@@ -0,0 +1,7 @@
+import { Lang } from './configure';
+/**
+ * Preferred method to set language.
+ * @param lang
+ * @return {void}
+ */
+export declare const setLang: (lang: Lang) => void;

package/build/cjs/utils/i18n.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLang = void 0;
+const configure_1 = require("./configure");
+/**
+ * Preferred method to set language.
+ * @param lang
+ * @return {void}
+ */
+const setLang = (lang) => {
+    (0, configure_1.configure)({ lang: lang });
+};
+exports.setLang = setLang;

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

@@ -0,0 +1,3 @@
+export * from './i18n';
+export * from './register-manager';
+export * from './update-manager';

package/build/cjs/utils/index.js

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

package/build/cjs/utils/register-manager.d.ts

@@ -0,0 +1,46 @@
+import { Plugin, PluginDefaultLayout, Settings } from '../typings';
+interface RegisterManagerDefaultLayout {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    minW: number;
+    minH: number;
+}
+export declare type RegisterManagerPluginLayout = RegisterManagerDefaultLayout & PluginDefaultLayout;
+export interface RegisterManagerPlugin extends Omit<Plugin, 'defaultLayout'> {
+    defaultLayout: RegisterManagerDefaultLayout & Plugin['defaultLayout'];
+}
+export declare type RegisterManagerGridLayout = {
+    margin: [number, number];
+    rowHeight: number;
+    cols: number;
+    containerPadding: [number, number];
+} & Settings['gridLayout'];
+export declare type RegisterManagerSettings = {
+    theme: string;
+} & Settings;
+export declare class RegisterManager {
+    private _items;
+    private _defaultLayout;
+    private _gridLayout;
+    private _settings;
+    registerPlugin(plugin: Plugin): void;
+    setSettings(settings?: Settings): void;
+    get settings(): RegisterManagerSettings;
+    get gridLayout(): {
+        margin: [number, number];
+        rowHeight: number;
+        cols: number;
+        containerPadding: [number, number];
+    } & {
+        margin?: [number, number] | undefined;
+        rowHeight?: number | undefined;
+        cols?: number | undefined;
+        containerPadding?: [number, number] | undefined;
+    };
+    getPlugins(): RegisterManagerPlugin[];
+    getItem(type: string): RegisterManagerPlugin;
+    check(type: string): boolean;
+}
+export {};

package/build/cjs/utils/register-manager.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterManager = void 0;
+const tslib_1 = require("tslib");
+class RegisterManager {
+    constructor() {
+        this._items = {};
+        this._defaultLayout = {
+            x: 0,
+            y: Infinity,
+            w: Infinity,
+            h: 4,
+            minW: 4,
+            minH: 2,
+        };
+        this._gridLayout = {
+            rowHeight: 18,
+            cols: 36,
+            margin: [2, 2],
+            containerPadding: [0, 0],
+        };
+        this._settings = {
+            theme: 'default',
+        };
+    }
+    registerPlugin(plugin) {
+        const { type, defaultLayout = {} } = plugin, item = tslib_1.__rest(plugin, ["type", "defaultLayout"]);
+        if (type in this._items) {
+            throw new Error(`DashKit.registerPlugins: type ${type} уже был зарегистрирован`);
+        }
+        if (typeof plugin.renderer !== 'function') {
+            throw new Error('DashKit.registerPlugins: renderer должна быть функцией');
+        }
+        this._items[type] = Object.assign(Object.assign({}, item), { type, defaultLayout: Object.assign(Object.assign({}, this._defaultLayout), defaultLayout) });
+    }
+    setSettings(settings = {}) {
+        Object.assign(this._settings, settings);
+        if (settings.gridLayout) {
+            this._gridLayout = Object.assign(Object.assign({}, this._gridLayout), settings.gridLayout);
+        }
+    }
+    get settings() {
+        return this._settings;
+    }
+    get gridLayout() {
+        return this._gridLayout;
+    }
+    getPlugins() {
+        return Object.values(this._items);
+    }
+    getItem(type) {
+        return this._items[type];
+    }
+    check(type) {
+        return type in this._items;
+    }
+}
+exports.RegisterManager = RegisterManager;

package/build/cjs/utils/update-manager.d.ts

@@ -0,0 +1,37 @@
+import { Config, ConfigItem, ItemsStateAndParams, ItemStateAndParams } from '../shared';
+import { AddConfigItem, WidgetLayout } from '../typings';
+import { RegisterManagerPluginLayout } from './register-manager';
+interface RemoveItemArg {
+    id: string;
+    config: Config;
+    itemsStateAndParams: ItemsStateAndParams;
+}
+interface ChangeStateAndParamsArg {
+    id: string;
+    config: Config;
+    itemsStateAndParams: ItemsStateAndParams;
+    stateAndParams: ItemStateAndParams;
+}
+export declare class UpdateManager {
+    static addItem({ item, namespace, layout, config, }: {
+        item: AddConfigItem;
+        namespace: string;
+        layout: RegisterManagerPluginLayout;
+        config: Config;
+    }): Config;
+    static editItem({ item, namespace, config, }: {
+        item: ConfigItem;
+        namespace: string;
+        config: Config;
+    }): Config;
+    static removeItem({ id, config, itemsStateAndParams }: RemoveItemArg): {
+        config: Config;
+        itemsStateAndParams: ItemsStateAndParams;
+    };
+    static updateLayout({ layout, config }: {
+        layout: WidgetLayout[];
+        config: Config;
+    }): Config;
+    static changeStateAndParams({ id: initiatorId, config, stateAndParams, itemsStateAndParams, }: ChangeStateAndParamsArg): ItemsStateAndParams;
+}
+export {};

package/build/cjs/utils/update-manager.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateManager = void 0;
+const tslib_1 = require("tslib");
+const immutability_helper_1 = tslib_1.__importStar(require("immutability-helper"));
+const hashids_1 = tslib_1.__importDefault(require("hashids"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+const shared_1 = require("../shared");
+const constants_1 = require("../constants");
+(0, immutability_helper_1.extend)('$auto', (value, object) => (object ? (0, immutability_helper_1.default)(object, value) : (0, immutability_helper_1.default)({}, value)));
+function removeItemVersion1({ id, config, itemsStateAndParams }) {
+    const itemIndex = config.items.findIndex((item) => item.id === id);
+    const removeItem = config.items[itemIndex];
+    const { defaults = {} } = removeItem;
+    const itemParamsKeys = Object.keys(defaults);
+    const getParams = (excludeId, items) => {
+        return Object.keys(items.reduce((acc, item) => {
+            if (item.id !== excludeId) {
+                Object.assign(acc, item.defaults);
+            }
+            return acc;
+        }, {}));
+    };
+    const allParamsKeys = getParams(id, config.items);
+    const allNamespaceParamsKeys = getParams(id, config.items.filter((item) => item.namespace === removeItem.namespace));
+    const uniqParamsKeys = itemParamsKeys.filter((key) => !allParamsKeys.includes(key));
+    const uniqNamespaceParamsKeys = itemParamsKeys.filter((key) => !allNamespaceParamsKeys.includes(key));
+    const withoutUniqItemsParams = Object.keys(itemsStateAndParams)
+        .filter((key) => key !== id)
+        .reduce((acc, key) => {
+        const { params } = itemsStateAndParams[key];
+        // в state из урла могут быть элементы, которых нет в config.items
+        const item = config.items.find((configItem) => configItem.id === key);
+        if (params && item) {
+            const { namespace } = item;
+            const currentUniqParamsKeys = namespace === removeItem.namespace ? uniqNamespaceParamsKeys : uniqParamsKeys;
+            const resultParams = (0, omit_1.default)(params, currentUniqParamsKeys);
+            if (Object.keys(params).length !== Object.keys(resultParams).length) {
+                acc[key] = {
+                    params: {
+                        $set: resultParams,
+                    },
+                };
+            }
+        }
+        return acc;
+    }, {});
+    const newItemsStateAndParams = (0, immutability_helper_1.default)(itemsStateAndParams, Object.assign({ $unset: [id] }, withoutUniqItemsParams));
+    const connections = config.connections.filter(({ from, to }) => id !== from && id !== to);
+    const newConfig = (0, immutability_helper_1.default)(config, {
+        items: {
+            $splice: [[itemIndex, 1]],
+        },
+        layout: {
+            $splice: [[itemIndex, 1]],
+        },
+        connections: {
+            $set: connections,
+        },
+    });
+    return {
+        config: newConfig,
+        itemsStateAndParams: newItemsStateAndParams,
+    };
+}
+function getAllowableChangedParams(item, stateAndParams, itemsStateAndParams) {
+    var _a;
+    let allowedParams = {};
+    if ((0, shared_1.isItemWithTabs)(item)) {
+        let tab;
+        if ('state' in stateAndParams && ((_a = stateAndParams.state) === null || _a === void 0 ? void 0 : _a.tabId)) {
+            tab = item.data.tabs.find(({ id }) => { var _a; return id === ((_a = stateAndParams.state) === null || _a === void 0 ? void 0 : _a.tabId); });
+        }
+        if (!tab) {
+            const tabId = (0, shared_1.resolveItemInnerId)({ item, itemsStateAndParams });
+            tab = item.data.tabs.find(({ id }) => id === tabId);
+        }
+        allowedParams = (0, pick_1.default)(stateAndParams.params, Object.keys((tab === null || tab === void 0 ? void 0 : tab.params) || {}));
+    }
+    else {
+        allowedParams = (0, pick_1.default)(stateAndParams.params, Object.keys(item.defaults || {}));
+    }
+    if (Object.keys(allowedParams).length !== Object.keys(stateAndParams.params || {}).length) {
+        console.warn('Параметры, которых нет в defaults, будут проигнорированы!');
+    }
+    return allowedParams;
+}
+function changeStateAndParamsVersion1({ id: initiatorId, config, stateAndParams, itemsStateAndParams, }) {
+    const hasState = 'state' in stateAndParams;
+    const { aliases } = config;
+    if ('params' in stateAndParams) {
+        const initiatorItem = config.items.find(({ id }) => id === initiatorId);
+        const allowableParams = getAllowableChangedParams(initiatorItem, stateAndParams, itemsStateAndParams);
+        const allowableParamsWithAliases = (0, shared_1.mergeParamsWithAliases)({
+            aliases,
+            namespace: initiatorItem.namespace,
+            params: allowableParams,
+        });
+        const ignoresInitiatorIds = config.connections
+            .filter(({ to }) => to === initiatorId)
+            .map(({ from }) => from);
+        const updateIds = config.items
+            .filter((item) => item.namespace === initiatorItem.namespace &&
+            !ignoresInitiatorIds.includes(item.id) &&
+            (!(0, shared_1.isItemWithTabs)(item) ||
+                ((0, shared_1.isItemWithTabs)(item) &&
+                    item.data.tabs.every(({ id }) => !ignoresInitiatorIds.includes(id)))))
+            .map(({ id }) => id);
+        return (0, immutability_helper_1.default)(itemsStateAndParams, updateIds.reduce((acc, currentId) => {
+            var _a;
+            acc[currentId] = {
+                $auto: Object.assign({ params: {
+                        [((_a = itemsStateAndParams[currentId]) === null || _a === void 0 ? void 0 : _a.params)
+                            ? '$merge'
+                            : '$set']: allowableParamsWithAliases,
+                    } }, (hasState && currentId === initiatorId
+                    ? { state: { $set: stateAndParams.state } }
+                    : {})),
+            };
+            return acc;
+        }, {}));
+    }
+    else if (hasState) {
+        return (0, immutability_helper_1.default)(itemsStateAndParams, {
+            [initiatorId]: {
+                $auto: {
+                    state: { $set: stateAndParams.state },
+                },
+            },
+        });
+    }
+    else {
+        return itemsStateAndParams;
+    }
+}
+class UpdateManager {
+    // TODO: проверять, что id нового элемента уникальный
+    static addItem({ item, namespace = constants_1.DEFAULT_NAMESPACE, layout, config, }) {
+        const layoutY = Math.max(0, ...config.layout.map(({ h, y }) => h + y));
+        const saveDefaultLayout = (0, pick_1.default)(layout, ['h', 'w', 'x', 'y']);
+        const hashids = new hashids_1.default(config.salt);
+        let counter = config.counter;
+        const resultData = (0, shared_1.isItemWithTabs)(item)
+            ? Object.assign(Object.assign({}, item.data), { tabs: item.data.tabs.map((tab) => tab.id ? tab : Object.assign(Object.assign({}, tab), { id: hashids.encode(++counter) })) }) : item.data;
+        const newItem = Object.assign(Object.assign({}, item), { id: hashids.encode(++counter), data: resultData, namespace });
+        return (0, immutability_helper_1.default)(config, {
+            items: { $push: [newItem] },
+            layout: { $push: [Object.assign(Object.assign({}, saveDefaultLayout), { y: layoutY, i: newItem.id })] },
+            counter: { $set: counter },
+        });
+    }
+    static editItem({ item, namespace = constants_1.DEFAULT_NAMESPACE, config, }) {
+        const hashids = new hashids_1.default(config.salt);
+        let counter = config.counter;
+        const itemIndex = config.items.findIndex(({ id }) => item.id === id);
+        const resultData = (0, shared_1.isItemWithTabs)(item)
+            ? Object.assign(Object.assign({}, item.data), { tabs: item.data.tabs.map((tab) => tab.id ? tab : Object.assign(Object.assign({}, tab), { id: hashids.encode(++counter) })) }) : item.data;
+        return (0, immutability_helper_1.default)(config, {
+            items: { [itemIndex]: { $set: Object.assign(Object.assign({}, item), { data: resultData, namespace }) } },
+            counter: { $set: counter },
+        });
+    }
+    static removeItem({ id, config, itemsStateAndParams = {} }) {
+        if ((0, shared_1.getCurrentVersion)(itemsStateAndParams) === 1) {
+            return removeItemVersion1({ id, config, itemsStateAndParams });
+        }
+        const itemIndex = config.items.findIndex((item) => item.id === id);
+        const item = config.items[itemIndex];
+        const itemIds = (0, shared_1.isItemWithTabs)(item)
+            ? [id].concat(item.data.tabs.map((tab) => tab.id))
+            : [id];
+        const connections = config.connections.filter(({ from, to }) => !itemIds.includes(from) && !itemIds.includes(to));
+        return {
+            config: (0, immutability_helper_1.default)(config, {
+                items: {
+                    $splice: [[itemIndex, 1]],
+                },
+                layout: {
+                    $splice: [[itemIndex, 1]],
+                },
+                connections: {
+                    $set: connections,
+                },
+            }),
+            itemsStateAndParams: (0, immutability_helper_1.default)(itemsStateAndParams, {
+                $unset: [id],
+                [shared_1.META_KEY]: {
+                    $set: (0, shared_1.deleteFromQueue)({
+                        id,
+                        itemsStateAndParams,
+                        config,
+                    }),
+                },
+            }),
+        };
+    }
+    static updateLayout({ layout, config }) {
+        return (0, immutability_helper_1.default)(config, {
+            layout: {
+                $set: layout.map(({ x, y, w, h, i }) => ({ x, y, w, h, i })),
+            },
+        });
+    }
+    static changeStateAndParams({ id: initiatorId, config, stateAndParams, itemsStateAndParams, }) {
+        var _a, _b;
+        if ((0, shared_1.getCurrentVersion)(itemsStateAndParams) === 1) {
+            return changeStateAndParamsVersion1({
+                id: initiatorId,
+                config,
+                stateAndParams,
+                itemsStateAndParams,
+            });
+        }
+        const hasState = 'state' in stateAndParams;
+        const { items } = config;
+        const itemsIds = items.map(({ id: itemId }) => itemId);
+        const itemsStateAndParamsIds = Object.keys((0, omit_1.default)(itemsStateAndParams, [shared_1.META_KEY]));
+        const unusedIds = itemsStateAndParamsIds.filter((id) => !itemsIds.includes(id));
+        const initiatorItem = items.find(({ id }) => id === initiatorId);
+        const newTabId = (_a = stateAndParams.state) === null || _a === void 0 ? void 0 : _a.tabId;
+        const isTabSwitched = (0, shared_1.isItemWithTabs)(initiatorItem) && Boolean(newTabId);
+        const currentMeta = (0, shared_1.getItemsStateAndParamsMeta)(itemsStateAndParams);
+        if ('params' in stateAndParams) {
+            const allowableParams = getAllowableChangedParams(initiatorItem, stateAndParams, itemsStateAndParams);
+            const tabId = (0, shared_1.isItemWithTabs)(initiatorItem)
+                ? newTabId || (0, shared_1.resolveItemInnerId)({ item: initiatorItem, itemsStateAndParams })
+                : undefined;
+            const meta = (0, shared_1.addToQueue)({ id: initiatorId, tabId, config, itemsStateAndParams });
+            let commandUpdateParams = ((_b = itemsStateAndParams[initiatorId]) === null || _b === void 0 ? void 0 : _b.params)
+                ? '$merge'
+                : '$set';
+            if (isTabSwitched) {
+                commandUpdateParams = '$set';
+            }
+            return (0, immutability_helper_1.default)(itemsStateAndParams, {
+                $unset: unusedIds,
+                [initiatorId]: {
+                    $auto: Object.assign({ params: {
+                            [commandUpdateParams]: allowableParams,
+                        } }, (hasState ? { state: { $set: stateAndParams.state } } : {})),
+                },
+                [shared_1.META_KEY]: { $set: meta },
+            });
+        }
+        else if (hasState) {
+            let metaSpec = {};
+            if (currentMeta && isTabSwitched) {
+                metaSpec = {
+                    [shared_1.META_KEY]: {
+                        $set: (0, shared_1.deleteFromQueue)({
+                            id: initiatorId,
+                            itemsStateAndParams,
+                            config,
+                        }),
+                    },
+                };
+            }
+            return (0, immutability_helper_1.default)(itemsStateAndParams, Object.assign({ $unset: unusedIds, [initiatorId]: {
+                    $auto: Object.assign({ state: { $set: stateAndParams.state } }, (isTabSwitched ? { $unset: ['params'] } : {})),
+                } }, (currentMeta
+                ? metaSpec
+                : { [shared_1.META_KEY]: { $set: (0, shared_1.getInitialItemsStateAndParamsMeta)() } })));
+        }
+        else {
+            return (0, immutability_helper_1.default)(itemsStateAndParams, Object.assign({ $unset: unusedIds }, (currentMeta
+                ? {}
+                : {
+                    [shared_1.META_KEY]: { $set: (0, shared_1.getInitialItemsStateAndParamsMeta)() },
+                })));
+        }
+    }
+}
+exports.UpdateManager = UpdateManager;

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

@@ -0,0 +1,50 @@
+import React from 'react';
+import GridLayout from '../GridLayout/GridLayout';
+import { SetConfigItem, Settings, SettingsProps, ContextProps, Plugin } from '../../typings';
+import { GlobalParams, Config, ConfigItem, ItemsStateAndParams } from '../../shared';
+import { OverlayControlItem } from '../OverlayControls/OverlayControls';
+interface DashKitGeneralProps {
+    config: Config;
+    editMode: boolean;
+}
+interface DashKitDefaultProps {
+    onItemEdit: (item: ConfigItem) => void;
+    onChange: (data: {
+        config: Config;
+        itemsStateAndParams: ItemsStateAndParams;
+    }) => void;
+    defaultGlobalParams: GlobalParams;
+    globalParams: GlobalParams;
+    itemsStateAndParams: ItemsStateAndParams;
+    settings: SettingsProps;
+    context: ContextProps;
+    overlayControls?: Record<string, OverlayControlItem[]>;
+    noOverlay?: boolean;
+    draggableHandleClassName?: string;
+    _EXPERIMENTAL_preventDoubleCompact?: boolean;
+}
+export interface DashKitProps extends DashKitGeneralProps, Partial<DashKitDefaultProps> {
+}
+declare type DashKitInnerProps = DashKitGeneralProps & DashKitDefaultProps;
+export declare class DashKit extends React.PureComponent<DashKitInnerProps> {
+    static defaultProps: DashKitDefaultProps;
+    static registerPlugins(...plugins: Plugin[]): void;
+    static setSettings(settings: Settings): void;
+    static setItem({ item: setItem, namespace, config, }: {
+        item: SetConfigItem;
+        namespace?: string;
+        config: Config;
+    }): Config;
+    static removeItem({ id, config, itemsStateAndParams, }: {
+        id: string;
+        config: Config;
+        itemsStateAndParams: ItemsStateAndParams;
+    }): {
+        config: Config;
+        itemsStateAndParams: ItemsStateAndParams;
+    };
+    metaRef: React.RefObject<GridLayout>;
+    render(): JSX.Element;
+    getItemsMeta(): any;
+}
+export {};