@gravity-ui/dashkit 3.0.1

package/build/cjs/plugins/Title/Title.css

@@ -0,0 +1,24 @@
+.dashkit-plugin-title {
+  display: flex;
+  align-items: flex-start;
+  height: 100%;
+  font-weight: 500;
+  padding-bottom: 5px;
+  padding-right: 5px;
+}
+.dashkit-plugin-title_size_l {
+  font-size: 24px;
+  line-height: 28px;
+}
+.dashkit-plugin-title_size_m {
+  font-size: 20px;
+  line-height: 24px;
+}
+.dashkit-plugin-title_size_s {
+  font-size: var(--yc-text-body-3-font-size);
+  line-height: 24px;
+}
+.dashkit-plugin-title_size_xs {
+  font-size: 15px;
+  line-height: 20px;
+}

package/build/cjs/plugins/Title/Title.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { PluginWidgetProps, Plugin } from '../../typings';
+export interface PluginTitleProps extends PluginWidgetProps {
+    data: {
+        size: 'l' | 'm' | 's' | 'xs';
+        text: string;
+        showInTOC: boolean;
+    } & PluginWidgetProps['data'];
+}
+export declare class PluginTitle extends React.Component<PluginTitleProps> {
+    render(): JSX.Element;
+}
+declare const plugin: Plugin<PluginTitleProps>;
+export default plugin;

package/build/cjs/plugins/Title/Title.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTitle = 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 b = (0, bem_cn_lite_1.default)('dashkit-plugin-title');
+class PluginTitle extends react_1.default.Component {
+    render() {
+        const { data } = this.props;
+        const text = data.text ? data.text : '';
+        const size = data.size ? data.size : false;
+        const id = data.showInTOC && text ? encodeURIComponent(text) : undefined;
+        return (react_1.default.createElement("div", { id: id, className: b({ size }) }, text));
+    }
+}
+exports.PluginTitle = PluginTitle;
+const plugin = {
+    type: 'title',
+    defaultLayout: { w: 36, h: 2 },
+    renderer(props, forwardedRef) {
+        return react_1.default.createElement(PluginTitle, Object.assign({}, props, { ref: forwardedRef }));
+    },
+};
+exports.default = plugin;

package/build/cjs/shared/constants/common.d.ts

@@ -0,0 +1,2 @@
+export declare const CURRENT_VERSION = 2;
+export declare const META_KEY = "__meta__";

package/build/cjs/shared/constants/common.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.META_KEY = exports.CURRENT_VERSION = void 0;
+exports.CURRENT_VERSION = 2;
+exports.META_KEY = '__meta__';

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

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

package/build/cjs/shared/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/shared/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './types';
+export * from './modules';
+export * from './units';

package/build/cjs/shared/index.js

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

package/build/cjs/shared/modules/__tests__/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/cjs/shared/modules/__tests__/helpers.test.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const helpers_1 = require("../helpers");
+const DEFAULT_CONTROL_ID = 'controlId';
+const DEFAULT_WIDGET_ID = 'widgetId';
+const DEFAULT_WIDGET_TAB_ID = 'widget_tabId';
+const NAMESPACE = 'default';
+const getMockedControlItem = ({ id = DEFAULT_CONTROL_ID, defaults, }) => ({
+    id,
+    defaults,
+    data: {},
+    type: 'control',
+    namespace: NAMESPACE,
+});
+const getMockedWidgetItem = ({ id = DEFAULT_WIDGET_ID, tabs }) => ({
+    id,
+    data: { tabs },
+    type: 'widget',
+    namespace: NAMESPACE,
+});
+describe('modules.helpers', () => {
+    describe('formQueueData', () => {
+        it('return correct queue data for control: common', () => {
+            const itemsStateAndParams = {
+                [DEFAULT_CONTROL_ID]: {
+                    params: {
+                        scale: 'd',
+                        view: 'normal',
+                    },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [{ id: DEFAULT_CONTROL_ID }],
+                    version: 2,
+                },
+            };
+            const controlItem1 = getMockedControlItem({ id: 'control-1' });
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [controlItem1], itemsStateAndParams }));
+            const controlItem2 = getMockedControlItem({ id: 'control-2', defaults: { scale: 'm' } });
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [controlItem2], itemsStateAndParams }));
+            const controlItem3 = getMockedControlItem({ defaults: { number: 'one', size: 's' } });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: {},
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [controlItem3], itemsStateAndParams }));
+            const controlItem4 = getMockedControlItem({ defaults: { scale: 'm', size: 's' } });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: { scale: 'd' },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [controlItem4], itemsStateAndParams }));
+            const controlItem5 = getMockedControlItem({
+                defaults: { scale: 'm', size: 's', view: 'contrast' },
+            });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: {
+                        scale: 'd',
+                        view: 'normal',
+                    },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [controlItem5], itemsStateAndParams }));
+        });
+        it('return correct queue data for widget: common', () => {
+            const itemsStateAndParams = {
+                [DEFAULT_WIDGET_ID]: {
+                    params: {
+                        scale: 'd',
+                        view: 'normal',
+                    },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [{ id: DEFAULT_WIDGET_ID, tabId: DEFAULT_WIDGET_TAB_ID }],
+                    version: 2,
+                },
+            };
+            const widgetItem1 = getMockedWidgetItem({ id: 'widget-1' });
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem1], itemsStateAndParams }));
+            const widgetItem2 = getMockedWidgetItem({
+                id: 'widget-2',
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID, params: { scale: 'm' } }],
+            });
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem2], itemsStateAndParams }));
+            const widgetItem3 = getMockedWidgetItem({
+                tabs: [{ id: 'widget-3-tabId', params: { scale: 'm' } }],
+            });
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem3], itemsStateAndParams }));
+            const widgetItem4 = getMockedWidgetItem({
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID }],
+            });
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: {},
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem4], itemsStateAndParams }));
+            const widgetItem5 = getMockedWidgetItem({
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID, params: { scale: 'm' } }],
+            });
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: { scale: 'd' },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem5], itemsStateAndParams }));
+        });
+        it('return correct queue data for widget: check tabs', () => {
+            const TAB_ID = 'default_tab_id';
+            const itemsStateAndParams1 = {
+                [DEFAULT_WIDGET_ID]: {
+                    params: { scale: 'd', view: 'normal' },
+                    state: { tabId: DEFAULT_WIDGET_TAB_ID },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [{ id: DEFAULT_WIDGET_ID, tabId: DEFAULT_WIDGET_TAB_ID }],
+                    version: 2,
+                },
+            };
+            const itemsStateAndParams2 = {
+                [DEFAULT_WIDGET_ID]: {
+                    params: { scale: 'd', view: 'normal' },
+                    state: { tabId: TAB_ID },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [{ id: DEFAULT_WIDGET_ID, tabId: TAB_ID }],
+                    version: 2,
+                },
+            };
+            const itemsStateAndParams3 = {
+                [DEFAULT_WIDGET_ID]: {
+                    params: { scale: 'd', view: 'normal' },
+                    state: { tabId: 'anyTabId' },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [{ id: DEFAULT_WIDGET_ID, tabId: 'anyTabId' }],
+                    version: 2,
+                },
+            };
+            const widgetItem = getMockedWidgetItem({
+                tabs: [
+                    { id: DEFAULT_WIDGET_TAB_ID, params: { scale: 'm' } },
+                    { id: TAB_ID, isDefault: true, params: { view: 'contrast' } },
+                ],
+            });
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: { scale: 'd' },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem], itemsStateAndParams: itemsStateAndParams1 }));
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: { view: 'normal' },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem], itemsStateAndParams: itemsStateAndParams2 }));
+            expect([]).toEqual((0, helpers_1.formQueueData)({ items: [widgetItem], itemsStateAndParams: itemsStateAndParams3 }));
+        });
+        it('return correct queue data for controls and widgets', () => {
+            const itemsStateAndParams = {
+                [DEFAULT_CONTROL_ID]: {
+                    params: {
+                        scale: 'd',
+                    },
+                },
+                [DEFAULT_WIDGET_ID]: {
+                    params: {
+                        view: 'normal',
+                    },
+                },
+                [constants_1.META_KEY]: {
+                    queue: [
+                        { id: DEFAULT_CONTROL_ID },
+                        { id: DEFAULT_WIDGET_ID, tabId: DEFAULT_WIDGET_TAB_ID },
+                    ],
+                    version: 2,
+                },
+            };
+            const widgetItem1 = getMockedWidgetItem({ id: 'widget-1' });
+            const widgetItem2 = getMockedWidgetItem({
+                id: 'widget-2',
+                tabs: [{ id: 'widget-2-tabId', params: { view: 'contrast' } }],
+            });
+            const widgetItem3 = getMockedWidgetItem({
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID, params: { view: 'contrast' } }],
+            });
+            const control1 = getMockedControlItem({ id: 'control-1' });
+            const control2 = getMockedControlItem({ defaults: { scale: 'm', view: 'contrast' } });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: { scale: 'd' },
+                },
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: { view: 'normal' },
+                },
+            ]).toEqual((0, helpers_1.formQueueData)({
+                items: [widgetItem2, widgetItem3, control1, widgetItem1, control2],
+                itemsStateAndParams,
+            }));
+        });
+    });
+});

package/build/cjs/shared/modules/helpers.d.ts

@@ -0,0 +1,42 @@
+import { PluginBase, ConfigItem, ItemsStateAndParams, StateAndParamsMetaData, StringParams, ConfigConnection, ConfigAliases, ConfigItemWithTabs, Config } from '../types';
+export declare function prerenderItems({ items, plugins, }: {
+    items: ConfigItem[];
+    plugins: PluginBase[];
+}): ConfigItem[];
+export declare function getItemsStateAndParamsMeta(itemsStateAndParams: ItemsStateAndParams): StateAndParamsMetaData | undefined;
+export declare function getCurrentVersion(itemsStateAndParams: ItemsStateAndParams): number;
+export declare function isItemWithTabs(item: Pick<ConfigItem, 'data'>): item is Pick<ConfigItemWithTabs, 'data'>;
+export declare type FormedQueueData = {
+    id: string;
+    namespace: string;
+    params: StringParams;
+};
+export declare function formQueueData({ items, itemsStateAndParams, }: {
+    items: ConfigItem[];
+    itemsStateAndParams: ItemsStateAndParams;
+}): FormedQueueData[];
+export declare function resolveItemInnerId({ item, itemsStateAndParams, }: {
+    item: ConfigItem;
+    itemsStateAndParams: ItemsStateAndParams;
+}): string;
+export declare function getMapItemsIgnores({ items, ignores, itemsStateAndParams, isFirstVersion, }: {
+    items: ConfigItem[];
+    ignores: ConfigConnection[];
+    itemsStateAndParams: ItemsStateAndParams;
+    isFirstVersion: boolean;
+}): Record<string, string[]>;
+export declare function mergeParamsWithAliases({ aliases, namespace, params, }: {
+    aliases: ConfigAliases;
+    namespace: string;
+    params: StringParams;
+}): StringParams;
+export declare function getInitialItemsStateAndParamsMeta(): StateAndParamsMetaData;
+interface ChangeQueueArg {
+    id: string;
+    tabId?: string;
+    config: Config;
+    itemsStateAndParams: ItemsStateAndParams;
+}
+export declare function addToQueue({ id, tabId, config, itemsStateAndParams, }: ChangeQueueArg): StateAndParamsMetaData;
+export declare function deleteFromQueue(data: ChangeQueueArg): StateAndParamsMetaData;
+export {};

package/build/cjs/shared/modules/helpers.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFromQueue = exports.addToQueue = exports.getInitialItemsStateAndParamsMeta = exports.mergeParamsWithAliases = exports.getMapItemsIgnores = exports.resolveItemInnerId = exports.formQueueData = exports.isItemWithTabs = exports.getCurrentVersion = exports.getItemsStateAndParamsMeta = exports.prerenderItems = void 0;
+const tslib_1 = require("tslib");
+const keyBy_1 = tslib_1.__importDefault(require("lodash/keyBy"));
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const invert_1 = tslib_1.__importDefault(require("lodash/invert"));
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const pick_1 = tslib_1.__importDefault(require("lodash/pick"));
+const constants_1 = require("../constants");
+function getNormalizedPlugins(plugins) {
+    return (0, keyBy_1.default)(plugins, 'type');
+}
+function prerenderItems({ items, plugins, }) {
+    const normalizedPlugins = getNormalizedPlugins(plugins);
+    return items.map((item) => {
+        const { type } = item;
+        const plugin = normalizedPlugins[type];
+        return typeof plugin.prerenderMiddleware === 'function'
+            ? plugin.prerenderMiddleware(item)
+            : item;
+    });
+}
+exports.prerenderItems = prerenderItems;
+function getItemsStateAndParamsMeta(itemsStateAndParams) {
+    const meta = itemsStateAndParams === null || itemsStateAndParams === void 0 ? void 0 : itemsStateAndParams[constants_1.META_KEY];
+    return meta;
+}
+exports.getItemsStateAndParamsMeta = getItemsStateAndParamsMeta;
+function getCurrentVersion(itemsStateAndParams) {
+    if ((0, isEmpty_1.default)(itemsStateAndParams)) {
+        return constants_1.CURRENT_VERSION;
+    }
+    const meta = getItemsStateAndParamsMeta(itemsStateAndParams);
+    if (!meta) {
+        const withParams = Object.keys(itemsStateAndParams).some((id) => {
+            return Boolean(itemsStateAndParams[id].params);
+        });
+        if (withParams) {
+            return 1;
+        }
+        return constants_1.CURRENT_VERSION;
+    }
+    return meta.version;
+}
+exports.getCurrentVersion = getCurrentVersion;
+function nonNullable(value) {
+    return value !== null && value !== undefined;
+}
+function isItemWithTabs(item) {
+    var _a;
+    return Array.isArray((_a = item === null || item === void 0 ? void 0 : item.data) === null || _a === void 0 ? void 0 : _a.tabs);
+}
+exports.isItemWithTabs = isItemWithTabs;
+// Массив параметров, которые исходят от виджетов, согласно очереди
+function formQueueData({ items, itemsStateAndParams, }) {
+    var _a;
+    const queue = ((_a = getItemsStateAndParamsMeta(itemsStateAndParams)) === null || _a === void 0 ? void 0 : _a.queue) || [];
+    const keyById = (0, keyBy_1.default)(items, 'id');
+    return queue
+        .map((queueItem) => {
+        var _a;
+        const { id: queueId, tabId } = queueItem;
+        const item = keyById[queueId];
+        if (!item) {
+            return null;
+        }
+        let itemDefaultParams;
+        if (isItemWithTabs(item)) {
+            if (!tabId || resolveItemInnerId({ item, itemsStateAndParams }) !== tabId) {
+                return null;
+            }
+            itemDefaultParams =
+                ((_a = item.data.tabs.find((tabData) => tabData.id === tabId)) === null || _a === void 0 ? void 0 : _a.params) || {};
+        }
+        else {
+            itemDefaultParams = item.defaults || {};
+        }
+        const itemQueueParams = (0, get_1.default)(itemsStateAndParams, [item.id, 'params'], {});
+        return {
+            id: item.id,
+            namespace: item.namespace,
+            params: (0, pick_1.default)(itemQueueParams, Object.keys(itemDefaultParams)),
+        };
+    })
+        .filter(nonNullable);
+}
+exports.formQueueData = formQueueData;
+function resolveItemInnerId({ item, itemsStateAndParams, }) {
+    var _a, _b;
+    const { id } = item;
+    const stateTabId = (_b = (_a = itemsStateAndParams[id]) === null || _a === void 0 ? void 0 : _a.state) === null || _b === void 0 ? void 0 : _b.tabId;
+    const { tabs } = item.data;
+    if (stateTabId && tabs.some((tab) => tab.id === stateTabId)) {
+        return stateTabId;
+    }
+    const indexIsDefault = tabs.findIndex(({ isDefault }) => isDefault);
+    return indexIsDefault === -1 ? tabs[0].id : tabs[indexIsDefault].id;
+}
+exports.resolveItemInnerId = resolveItemInnerId;
+// В config.connections в from/to может быть как id item'a (item.id), так и id таба (item.data.tabs[].id)
+// Тут мы нормализуем к виду Record<itemId: ignoredItemId[]>
+function getMapItemsIgnores({ items, ignores, itemsStateAndParams, isFirstVersion, }) {
+    // Record<itemId, innerId (tabId | itemId)>
+    const mapIds = items.reduce((acc, item) => {
+        return Object.assign(Object.assign({}, acc), { [item.id]: isItemWithTabs(item)
+                ? resolveItemInnerId({ item, itemsStateAndParams })
+                : item.id });
+    }, {});
+    // Record<innerId (tabId | itemId), itemId>
+    const invertedMapIds = (0, invert_1.default)(mapIds);
+    return items.reduce((acc, item) => {
+        return Object.assign(Object.assign({}, acc), { [item.id]: ignores
+                .filter(({ from, to }) => {
+                if (isFirstVersion) {
+                    // В первой версии был баг - если есть игнор на один таб, то весь виджет игнорит селектор.
+                    // Повторяем это неправильное поведение,
+                    // иначе будут прилетать дефолты селекта в табы, которые не игнорят.
+                    const fromInTabs = isItemWithTabs(item) && item.data.tabs.some(({ id }) => id === from);
+                    return (from === item.id || fromInTabs) && invertedMapIds[to];
+                }
+                return from === mapIds[item.id] && invertedMapIds[to];
+            })
+                .map(({ to }) => invertedMapIds[to]) });
+    }, {});
+}
+exports.getMapItemsIgnores = getMapItemsIgnores;
+function mergeParamsWithAliases({ aliases, namespace, params, }) {
+    const aliasesByNamespace = (0, get_1.default)(aliases, [namespace], []);
+    return Object.keys(params).reduce((matchedParams, paramKey) => {
+        const paramValue = params[paramKey];
+        const collectAliasesParamsKeys = aliasesByNamespace.reduce((collect, group) => {
+            return group.includes(paramKey) ? collect.concat(group) : collect;
+        }, [paramKey]);
+        return Object.assign(Object.assign({}, matchedParams), collectAliasesParamsKeys.reduce((acc, matchedKey) => {
+            return Object.assign(Object.assign({}, acc), { [matchedKey]: paramValue });
+        }, {}));
+    }, {});
+}
+exports.mergeParamsWithAliases = mergeParamsWithAliases;
+function getInitialItemsStateAndParamsMeta() {
+    return {
+        queue: [],
+        version: constants_1.CURRENT_VERSION,
+    };
+}
+exports.getInitialItemsStateAndParamsMeta = getInitialItemsStateAndParamsMeta;
+function addToQueue({ id, tabId, config, itemsStateAndParams, }) {
+    const queueItem = { id };
+    if (tabId) {
+        queueItem.tabId = tabId;
+    }
+    const meta = getItemsStateAndParamsMeta(itemsStateAndParams);
+    if (!meta) {
+        return { queue: [queueItem], version: constants_1.CURRENT_VERSION };
+    }
+    const { items } = config;
+    const actualIds = items.map((item) => item.id);
+    const metaQueue = meta.queue || [];
+    return {
+        queue: metaQueue
+            .filter((item) => actualIds.includes(item.id) && item.id !== id)
+            .concat(queueItem),
+        version: meta.version || constants_1.CURRENT_VERSION,
+    };
+}
+exports.addToQueue = addToQueue;
+function deleteFromQueue(data) {
+    const meta = addToQueue(data);
+    return Object.assign(Object.assign({}, meta), { queue: meta.queue.slice(0, -1) });
+}
+exports.deleteFromQueue = deleteFromQueue;

package/build/cjs/shared/modules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers';
+export * from './state-and-params';

package/build/cjs/shared/modules/index.js

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

package/build/cjs/shared/modules/state-and-params.d.ts

@@ -0,0 +1,16 @@
+import { GlobalParams, Config, ItemsStateAndParams, PluginBase, StringParams, ItemState } from '../types';
+export interface GetItemsParamsArg {
+    defaultGlobalParams: GlobalParams;
+    globalParams: GlobalParams;
+    config: Config;
+    itemsStateAndParams: ItemsStateAndParams;
+    plugins: PluginBase[];
+}
+declare type GetItemsParamsReturn = Record<string, StringParams>;
+export declare function getItemsParams({ defaultGlobalParams, globalParams, config, itemsStateAndParams, plugins, }: GetItemsParamsArg): GetItemsParamsReturn;
+export declare function getItemsState({ config, itemsStateAndParams, }: {
+    config: Config;
+    itemsStateAndParams: ItemsStateAndParams;
+}): Record<string, ItemState>;
+export declare function getItemsStateAndParams({ defaultGlobalParams, globalParams, config, itemsStateAndParams, plugins, }: GetItemsParamsArg): ItemsStateAndParams;
+export {};

package/build/cjs/shared/modules/state-and-params.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getItemsStateAndParams = exports.getItemsState = exports.getItemsParams = void 0;
+const tslib_1 = require("tslib");
+const groupBy_1 = tslib_1.__importDefault(require("lodash/groupBy"));
+const helpers_1 = require("./helpers");
+const constants_1 = require("../constants");
+function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, itemsStateAndParams, plugins, }) {
+    const { aliases, connections } = config;
+    const items = (0, helpers_1.prerenderItems)({ items: config.items, plugins });
+    const isFirstVersion = (0, helpers_1.getCurrentVersion)(itemsStateAndParams) === 1;
+    const queueData = isFirstVersion
+        ? []
+        : (0, helpers_1.formQueueData)({ items, itemsStateAndParams });
+    // В будущем учитывать не только игноры, когда такой kind появится
+    const mapItemsIgnores = (0, helpers_1.getMapItemsIgnores)({
+        items,
+        ignores: connections.filter(({ kind }) => kind === 'ignore'),
+        itemsStateAndParams,
+        isFirstVersion,
+    });
+    const groupByNamespace = (0, groupBy_1.default)(items, 'namespace');
+    const itemsWithDefaultsByNamespace = Object.keys(groupByNamespace).reduce((acc, namespace) => {
+        return Object.assign(Object.assign({}, acc), { 
+            // Сейчас дефолты только у Селектов, затем для виджетов нужно доставать из item.data.tabs[].defaults
+            // но определиться с порядком их применения
+            [namespace]: groupByNamespace[namespace].filter((item) => item.defaults) });
+    }, {});
+    return items.reduce((itemsParams, item) => {
+        var _a;
+        const { id, namespace } = item;
+        const getMergedParams = (params) => (0, helpers_1.mergeParamsWithAliases)({ aliases, namespace, params: params || {} });
+        const itemIgnores = mapItemsIgnores[id];
+        const affectingItemsWithDefaults = itemsWithDefaultsByNamespace[namespace].filter((itemWithDefaults) => !itemIgnores.includes(itemWithDefaults.id));
+        let itemParams = Object.assign({}, getMergedParams(defaultGlobalParams), 
+        // Стартовые дефолтные параметры
+        affectingItemsWithDefaults.reduceRight((defaultParams, itemWithDefaults) => {
+            return Object.assign(Object.assign({}, defaultParams), getMergedParams(itemWithDefaults.defaults || {}));
+        }, {}), getMergedParams(globalParams));
+        if (isFirstVersion) {
+            itemParams = Object.assign(itemParams, ((_a = itemsStateAndParams === null || itemsStateAndParams === void 0 ? void 0 : itemsStateAndParams[id]) === null || _a === void 0 ? void 0 : _a.params) || {});
+        }
+        else {
+            itemParams = Object.assign(itemParams, 
+            // Параметры согласно очереди применения параметров
+            queueData.reduce((queueParams, data) => {
+                if (data.namespace !== namespace || itemIgnores.includes(data.id)) {
+                    return queueParams;
+                }
+                return Object.assign(Object.assign({}, queueParams), getMergedParams(data.params));
+            }, {}));
+        }
+        return Object.assign(Object.assign({}, itemsParams), { [id]: itemParams });
+    }, {});
+}
+exports.getItemsParams = getItemsParams;
+function getItemsState({ config, itemsStateAndParams, }) {
+    return config.items.reduce((acc, { id }) => {
+        var _a;
+        acc[id] = ((_a = itemsStateAndParams === null || itemsStateAndParams === void 0 ? void 0 : itemsStateAndParams[id]) === null || _a === void 0 ? void 0 : _a.state) || {};
+        return acc;
+    }, {});
+}
+exports.getItemsState = getItemsState;
+function getItemsStateAndParams({ defaultGlobalParams = {}, globalParams = {}, config, itemsStateAndParams, plugins, }) {
+    const params = getItemsParams({
+        defaultGlobalParams,
+        globalParams,
+        config,
+        itemsStateAndParams,
+        plugins,
+    });
+    const state = getItemsState({ config, itemsStateAndParams });
+    const uniqIds = new Set([...Object.keys(params), ...Object.keys(state)]);
+    const result = Array.from(uniqIds).reduce((acc, id) => {
+        const data = {};
+        if (id in params) {
+            data.params = params[id];
+        }
+        if (id in state) {
+            data.state = state[id];
+        }
+        return Object.assign(Object.assign({}, acc), { [id]: data });
+    }, {});
+    const version = (0, helpers_1.getCurrentVersion)(itemsStateAndParams);
+    if (version === 1) {
+        return result;
+    }
+    const meta = {
+        [constants_1.META_KEY]: itemsStateAndParams[constants_1.META_KEY],
+    };
+    return Object.assign(Object.assign({}, meta), result);
+}
+exports.getItemsStateAndParams = getItemsStateAndParams;

package/build/cjs/shared/types/common.d.ts

@@ -0,0 +1,5 @@
+export declare type Dictionary<T = unknown> = Record<string, T>;
+export interface StringParams extends Dictionary<string | string[]> {
+}
+export interface GlobalParams extends StringParams {
+}

package/build/cjs/shared/types/common.js

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