@gravity-ui/dashkit 5.2.0 → 5.4.0

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

@@ -64,9 +64,14 @@ function removeItemVersion1({ id, config, itemsStateAndParams }) {
         itemsStateAndParams: newItemsStateAndParams,
     };
 }
-function getAllowableChangedParams(item, stateAndParams, itemsStateAndParams) {
+function getAllowableChangedParams(item, stateAndParams, itemsStateAndParams, paramsSettings) {
     var _a;
+    const paramsTypeName = (paramsSettings === null || paramsSettings === void 0 ? void 0 : paramsSettings.type) || 'params';
+    const isActionParamsMode = paramsTypeName === 'actionParams';
     let allowedParams = {};
+    const stateParamsConf = isActionParamsMode
+        ? (0, shared_1.pickActionParamsFromParams)(stateAndParams.params, false)
+        : stateAndParams.params;
     if ((0, shared_1.isItemWithTabs)(item)) {
         let tab;
         if ('state' in stateAndParams && ((_a = stateAndParams.state) === null || _a === void 0 ? void 0 : _a.tabId)) {
@@ -76,14 +81,19 @@ function getAllowableChangedParams(item, stateAndParams, itemsStateAndParams) {
             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) || {}));
+        allowedParams = (0, pick_1.default)(stateParamsConf, Object.keys((tab === null || tab === void 0 ? void 0 : tab.params) || {}));
     }
     else {
-        allowedParams = (0, pick_1.default)(stateAndParams.params, Object.keys(item.defaults || {}));
+        allowedParams = (0, pick_1.default)(stateParamsConf, Object.keys(item.defaults || {}));
     }
-    if (Object.keys(allowedParams).length !== Object.keys(stateAndParams.params || {}).length) {
+    if (Object.keys(allowedParams || {}).length !== Object.keys(stateParamsConf || {}).length) {
         console.warn('Параметры, которых нет в defaults, будут проигнорированы!');
     }
+    if (isActionParamsMode) {
+        return (paramsSettings === null || paramsSettings === void 0 ? void 0 : paramsSettings.returnPrefix)
+            ? (0, shared_1.transformParamsToActionParams)(allowedParams)
+            : allowedParams;
+    }
     return allowedParams;
 }
 function changeStateAndParamsVersion1({ id: initiatorId, config, stateAndParams, itemsStateAndParams, }) {
@@ -244,6 +254,7 @@ class UpdateManager {
         const currentMeta = (0, shared_1.getItemsStateAndParamsMeta)(itemsStateAndParams);
         if ('params' in stateAndParams) {
             const allowableParams = getAllowableChangedParams(initiatorItem, stateAndParams, itemsStateAndParams);
+            const allowableActionParams = getAllowableChangedParams(initiatorItem, stateAndParams, itemsStateAndParams, { type: 'actionParams', returnPrefix: true });
             const tabId = (0, shared_1.isItemWithTabs)(initiatorItem)
                 ? newTabId || (0, shared_1.resolveItemInnerId)({ item: initiatorItem, itemsStateAndParams })
                 : undefined;
@@ -254,15 +265,16 @@ class UpdateManager {
             if (isTabSwitched) {
                 commandUpdateParams = '$set';
             }
-            return (0, immutability_helper_1.default)(itemsStateAndParams, {
+            const obj = {
                 $unset: unusedIds,
                 [initiatorId]: {
                     $auto: Object.assign({ params: {
-                            [commandUpdateParams]: allowableParams,
+                            [commandUpdateParams]: Object.assign(Object.assign({}, allowableParams), allowableActionParams),
                         } }, (hasState ? { state: { $set: stateAndParams.state } } : {})),
                 },
                 [shared_1.META_KEY]: { $set: meta },
-            });
+            };
+            return (0, immutability_helper_1.default)(itemsStateAndParams, obj);
         }
         else if (hasState) {
             let metaSpec = {};

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

@@ -1,2 +1,3 @@
 export declare const CURRENT_VERSION = 2;
 export declare const META_KEY = "__meta__";
+export declare const ACTION_PARAM_PREFIX = "_ap_";

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

@@ -1,2 +1,3 @@
 export const CURRENT_VERSION = 2;
 export const META_KEY = '__meta__';
+export const ACTION_PARAM_PREFIX = '_ap_';

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

@@ -1,5 +1,5 @@
-import { META_KEY } from '../../constants';
-import { formQueueData } from '../helpers';
+import { ACTION_PARAM_PREFIX, META_KEY } from '../../constants';
+import { formQueueData, hasActionParams, pickExceptActionParamsFromParams, transformParamsToActionParams, } from '../helpers';
 const DEFAULT_CONTROL_ID = 'controlId';
 const DEFAULT_WIDGET_ID = 'widgetId';
 const DEFAULT_WIDGET_TAB_ID = 'widget_tabId';
@@ -11,6 +11,59 @@ const getMockedControlItem = ({ id = DEFAULT_CONTROL_ID, defaults, }) => ({
     type: 'control',
     namespace: NAMESPACE,
 });
+const stateAndParamsWithParamsOnly = {
+    params: {
+        paramName: 'param1',
+    },
+};
+const stateAndParamsWithStateOnly = {
+    state: {
+        tabId: 'tabId1',
+    },
+};
+const stateAndParamsWithActionParamsInParamsOnly = {
+    params: {
+        _ap_paramName: 'param1',
+    },
+};
+const stateAndParamsWithStateAndActionParamsInParams = {
+    state: {
+        tabId: 'tabId1',
+    },
+    params: {
+        _ap_paramName: 'param1',
+    },
+};
+const stateAndParamsWithParamsAndActionParamsInParams = {
+    params: {
+        paramName2: 'param2',
+        _ap_paramName: 'param1',
+    },
+};
+const paramsToTransform = {
+    in: {
+        param1: 'val 1',
+        param2: 'val 2',
+    },
+    out: {
+        [`${ACTION_PARAM_PREFIX}param1`]: 'val 1',
+        [`${ACTION_PARAM_PREFIX}param2`]: 'val 2',
+    },
+};
+const exeptActionParam1 = {
+    in: stateAndParamsWithParamsOnly.params,
+    out: stateAndParamsWithParamsOnly.params,
+};
+const exeptActionParam2 = {
+    in: stateAndParamsWithActionParamsInParamsOnly.params,
+    out: {},
+};
+const exeptActionParam3 = {
+    in: stateAndParamsWithParamsAndActionParamsInParams.params,
+    out: {
+        paramName2: 'param2',
+    },
+};
 const getMockedWidgetItem = ({ id = DEFAULT_WIDGET_ID, tabs }) => ({
     id,
     data: { tabs },
@@ -212,4 +265,28 @@ describe('modules.helpers', () => {
             }));
         });
     });
+    describe('actionParams helpers', () => {
+        it('check hasActionParams', () => {
+            const empty = hasActionParams({});
+            expect(empty).toBeFalsy();
+            const withParamsOnly = hasActionParams(stateAndParamsWithParamsOnly);
+            expect(withParamsOnly).toBeFalsy();
+            const withStateOnly = hasActionParams(stateAndParamsWithStateOnly);
+            expect(withStateOnly).toBeFalsy();
+            const withAPinParams = hasActionParams(stateAndParamsWithActionParamsInParamsOnly);
+            expect(withAPinParams).toBeTruthy();
+            const withAPinParamsNState = hasActionParams(stateAndParamsWithStateAndActionParamsInParams);
+            expect(withAPinParamsNState).toBeTruthy();
+            const withParamsAndAPinParams = hasActionParams(stateAndParamsWithParamsAndActionParamsInParams);
+            expect(withParamsAndAPinParams).toBeTruthy();
+        });
+        it('check transformParamsToActionParams', () => {
+            expect(paramsToTransform.out).toEqual(transformParamsToActionParams(paramsToTransform.in));
+        });
+        it('check pickExceptActionParamsFromParams', () => {
+            expect(exeptActionParam1.out).toEqual(pickExceptActionParamsFromParams(exeptActionParam1.in));
+            expect(exeptActionParam2.out).toEqual(pickExceptActionParamsFromParams(exeptActionParam2.in));
+            expect(exeptActionParam3.out).toEqual(pickExceptActionParamsFromParams(exeptActionParam3.in));
+        });
+    });
 });

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

@@ -1,4 +1,4 @@
-import { PluginBase, ConfigItem, ItemsStateAndParams, StateAndParamsMetaData, StringParams, ConfigConnection, ConfigAliases, ConfigItemWithTabs, Config } from '../types';
+import { PluginBase, ConfigItem, ItemsStateAndParams, StateAndParamsMetaData, StringParams, ConfigConnection, ConfigAliases, ConfigItemWithTabs, Config, ItemStateAndParams } from '../types';
 export declare function prerenderItems({ items, plugins, }: {
     items: ConfigItem[];
     plugins: PluginBase[];
@@ -25,10 +25,11 @@ export declare function getMapItemsIgnores({ items, ignores, itemsStateAndParams
     itemsStateAndParams: ItemsStateAndParams;
     isFirstVersion: boolean;
 }): Record<string, string[]>;
-export declare function mergeParamsWithAliases({ aliases, namespace, params, }: {
+export declare function mergeParamsWithAliases({ aliases, namespace, params, actionParams, }: {
     aliases: ConfigAliases;
     namespace: string;
     params: StringParams;
+    actionParams?: StringParams;
 }): StringParams;
 export declare function getInitialItemsStateAndParamsMeta(): StateAndParamsMetaData;
 interface ChangeQueueArg {
@@ -39,4 +40,42 @@ interface ChangeQueueArg {
 }
 export declare function addToQueue({ id, tabId, config, itemsStateAndParams, }: ChangeQueueArg): StateAndParamsMetaData;
 export declare function deleteFromQueue(data: ChangeQueueArg): StateAndParamsMetaData;
+/**
+ * public function for getting only actionParams from object (all fields with keys that contains prefix)
+ * @param params - object for pick fields
+ * @param returnWithPrefix - format of returning actionParams fields (with actionParams prefix or without them)
+ *
+ * ex1: pickActionParamsFromParams({City: 'NY', _ap_Year: '2023'}, true) returns {_ap_Year: '2023'}
+ * ex2: pickActionParamsFromParams({City: 'NY', _ap_Year: '2023'}) returns {Year: '2023'}
+ */
+export declare function pickActionParamsFromParams(params: ItemStateAndParams['params'], returnWithPrefix?: boolean): StringParams;
+/**
+ * public function for getting params from object without actionParams
+ * @param params
+ */
+export declare function pickExceptActionParamsFromParams(params: ItemStateAndParams['params']): StringParams;
+/**
+ * public function for transforming object to actionParams format
+ * @param params
+ */
+export declare function transformParamsToActionParams(params: ItemStateAndParams['params']): StringParams;
+/**
+ * check if object contains actionParams
+ * @param conf
+ */
+export declare function hasActionParam(conf?: StringParams): boolean;
+/**
+ * check if ItemStateAndParams object has actionParams in params or state field
+ * @param stateAndParams
+ */
+export declare function hasActionParams(stateAndParams: ItemStateAndParams): boolean;
+/**
+ * Collect array of actionParams keys with prefix (_ap_) that must be cleared from widget defaults
+ * @param defaultWidgetParams
+ * @param queueWidgetParams
+ */
+export declare function getDefaultsActionParamsToClear({ defaultWidgetParams, queueWidgetParams, }: {
+    defaultWidgetParams: StringParams;
+    queueWidgetParams: StringParams;
+}): string[];
 export {};

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

@@ -3,7 +3,8 @@ import get from 'lodash/get';
 import invert from 'lodash/invert';
 import isEmpty from 'lodash/isEmpty';
 import pick from 'lodash/pick';
-import { META_KEY, CURRENT_VERSION } from '../constants';
+import intersection from 'lodash/intersection';
+import { META_KEY, CURRENT_VERSION, ACTION_PARAM_PREFIX } from '../constants';
 function getNormalizedPlugins(plugins) {
     return keyBy(plugins, 'type');
 }
@@ -44,7 +45,7 @@ export 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);
 }
-// Массив параметров, которые исходят от виджетов, согласно очереди
+// Array of parameters from widgets according to queue
 export function formQueueData({ items, itemsStateAndParams, }) {
     var _a;
     const queue = ((_a = getItemsStateAndParamsMeta(itemsStateAndParams)) === null || _a === void 0 ? void 0 : _a.queue) || [];
@@ -69,10 +70,24 @@ export function formQueueData({ items, itemsStateAndParams, }) {
             itemDefaultParams = item.defaults || {};
         }
         const itemQueueParams = get(itemsStateAndParams, [item.id, 'params'], {});
+        const filteredParamsByDefaults = pick(itemQueueParams, Object.keys(itemDefaultParams));
+        /**
+         * filtering actionParams without prefixes by defaults params
+         * ex.:
+         * itemDefaultParams contains 'Country' in defaults
+         * and we receive '_ap_Country' and '_ap_City' in itemQueueParams
+         * we need to ignore '_ap_City' param because we don't have actionParam without prefix ('City') in defaults
+         */
+        const actionParams = pickActionParamsFromParams(itemQueueParams, false) || {};
+        const filteredActionParamsByDefaults = pick(actionParams, Object.keys(itemDefaultParams));
+        /**
+         * merging filtered params and filtered actionParams with prefixes
+         */
+        const params = Object.assign(Object.assign({}, filteredParamsByDefaults), transformParamsToActionParams(filteredActionParamsByDefaults));
         return {
             id: item.id,
             namespace: item.namespace,
-            params: pick(itemQueueParams, Object.keys(itemDefaultParams)),
+            params,
         };
     })
         .filter(nonNullable);
@@ -114,10 +129,11 @@ export function getMapItemsIgnores({ items, ignores, itemsStateAndParams, isFirs
                 .map(({ to }) => invertedMapIds[to]) });
     }, {});
 }
-export function mergeParamsWithAliases({ aliases, namespace, params, }) {
+export function mergeParamsWithAliases({ aliases, namespace, params, actionParams, }) {
     const aliasesByNamespace = get(aliases, [namespace], []);
-    return Object.keys(params).reduce((matchedParams, paramKey) => {
-        const paramValue = params[paramKey];
+    const items = Object.assign(Object.assign({}, (params || {})), (actionParams || {}));
+    return Object.keys(items).reduce((matchedParams, paramKey) => {
+        const paramValue = items[paramKey];
         const collectAliasesParamsKeys = aliasesByNamespace.reduce((collect, group) => {
             return group.includes(paramKey) ? collect.concat(group) : collect;
         }, [paramKey]);
@@ -155,3 +171,91 @@ export function deleteFromQueue(data) {
     const meta = addToQueue(data);
     return Object.assign(Object.assign({}, meta), { queue: meta.queue.slice(0, -1) });
 }
+/**
+ * public function for getting only actionParams from object (all fields with keys that contains prefix)
+ * @param params - object for pick fields
+ * @param returnWithPrefix - format of returning actionParams fields (with actionParams prefix or without them)
+ *
+ * ex1: pickActionParamsFromParams({City: 'NY', _ap_Year: '2023'}, true) returns {_ap_Year: '2023'}
+ * ex2: pickActionParamsFromParams({City: 'NY', _ap_Year: '2023'}) returns {Year: '2023'}
+ */
+export function pickActionParamsFromParams(params, returnWithPrefix) {
+    if (!params || isEmpty(params)) {
+        return {};
+    }
+    const actionParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        // starts with actionParams prefix (from'_ap_')
+        if (key.startsWith(ACTION_PARAM_PREFIX)) {
+            const paramName = returnWithPrefix ? key : key.slice(ACTION_PARAM_PREFIX.length);
+            actionParams[paramName] = val;
+        }
+    }
+    return actionParams;
+}
+/**
+ * public function for getting params from object without actionParams
+ * @param params
+ */
+export function pickExceptActionParamsFromParams(params) {
+    if (!params || isEmpty(params)) {
+        return {};
+    }
+    const onlyParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        if (!key.startsWith(ACTION_PARAM_PREFIX)) {
+            onlyParams[key] = val;
+        }
+    }
+    return onlyParams;
+}
+/**
+ * public function for transforming object to actionParams format
+ * @param params
+ */
+export function transformParamsToActionParams(params) {
+    if (!params || isEmpty(params)) {
+        return {};
+    }
+    const actionParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        actionParams[`${ACTION_PARAM_PREFIX}${key}`] = val;
+    }
+    return actionParams;
+}
+/**
+ * check if object contains actionParams
+ * @param conf
+ */
+export function hasActionParam(conf) {
+    return Object.keys(conf || {}).some((key) => key.startsWith(ACTION_PARAM_PREFIX));
+}
+/**
+ * check if ItemStateAndParams object has actionParams in params or state field
+ * @param stateAndParams
+ */
+export function hasActionParams(stateAndParams) {
+    if (!stateAndParams || isEmpty(stateAndParams)) {
+        return false;
+    }
+    return hasActionParam(stateAndParams.params);
+}
+/**
+ * Collect array of actionParams keys with prefix (_ap_) that must be cleared from widget defaults
+ * @param defaultWidgetParams
+ * @param queueWidgetParams
+ */
+export function getDefaultsActionParamsToClear({ defaultWidgetParams, queueWidgetParams, }) {
+    const widgetDefaultsWithActionParams = hasActionParam(defaultWidgetParams)
+        ? pickActionParamsFromParams(defaultWidgetParams)
+        : null;
+    if (!widgetDefaultsWithActionParams) {
+        return [];
+    }
+    // clear default actionParams if some param with the same name without prefix affected on current widget
+    // ex.: queueWidgetParams contain {Year: 1970} and default actionParams contain {_ap_Year: 2000}
+    const actionParamKeyToClear = intersection(Object.keys(queueWidgetParams), Object.keys(widgetDefaultsWithActionParams));
+    return actionParamKeyToClear.length
+        ? actionParamKeyToClear.map((key) => `${ACTION_PARAM_PREFIX}${key}`)
+        : [];
+}

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

@@ -1,6 +1,8 @@
 import groupBy from 'lodash/groupBy';
-import { prerenderItems, formQueueData, getMapItemsIgnores, mergeParamsWithAliases, getCurrentVersion, } from './helpers';
+import intersection from 'lodash/intersection';
+import omit from 'lodash/omit';
 import { META_KEY } from '../constants';
+import { prerenderItems, formQueueData, getMapItemsIgnores, mergeParamsWithAliases, getCurrentVersion, pickActionParamsFromParams, hasActionParam, pickExceptActionParamsFromParams, transformParamsToActionParams, isItemWithTabs, resolveItemInnerId, getDefaultsActionParamsToClear, } from './helpers';
 export function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, itemsStateAndParams, plugins, }) {
     const { aliases, connections } = config;
     const items = prerenderItems({ items: config.items, plugins });
@@ -8,7 +10,7 @@ export function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, co
     const queueData = isFirstVersion
         ? []
         : formQueueData({ items, itemsStateAndParams });
-    // В будущем учитывать не только игноры, когда такой kind появится
+    // to consider other kind types in future (not only ignore)
     const mapItemsIgnores = getMapItemsIgnores({
         items,
         ignores: connections.filter(({ kind }) => kind === 'ignore'),
@@ -18,35 +20,70 @@ export function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, co
     const groupByNamespace = groupBy(items, 'namespace');
     const itemsWithDefaultsByNamespace = Object.keys(groupByNamespace).reduce((acc, namespace) => {
         return Object.assign(Object.assign({}, acc), { 
-            // Сейчас дефолты только у Селектов, затем для виджетов нужно доставать из item.data.tabs[].defaults
-            // но определиться с порядком их применения
+            // there are defaults only in selectors by now, need to get them from item.data.tabs[].defaults for widgets
+            // but make a decision about there's order first
             [namespace]: groupByNamespace[namespace].filter((item) => item.defaults) });
     }, {});
     return items.reduce((itemsParams, item) => {
-        var _a;
+        var _a, _b;
         const { id, namespace } = item;
-        const getMergedParams = (params) => mergeParamsWithAliases({ aliases, namespace, params: params || {} });
+        let defaultWidgetParams = {};
+        if (isItemWithTabs(item)) {
+            const currentWidgetTabId = resolveItemInnerId({ item, itemsStateAndParams });
+            const itemTabs = item.data.tabs;
+            defaultWidgetParams =
+                ((_a = itemTabs.find((tabItem) => (tabItem === null || tabItem === void 0 ? void 0 : tabItem.id) === currentWidgetTabId)) === null || _a === void 0 ? void 0 : _a.params) || {};
+        }
+        else {
+            defaultWidgetParams = item.defaults || {};
+        }
+        const getMergedParams = (params, actionParams) => mergeParamsWithAliases({ aliases, namespace, params: params || {}, actionParams });
         const itemIgnores = mapItemsIgnores[id];
         const affectingItemsWithDefaults = itemsWithDefaultsByNamespace[namespace].filter((itemWithDefaults) => !itemIgnores.includes(itemWithDefaults.id));
         let itemParams = Object.assign({}, getMergedParams(defaultGlobalParams), 
-        // Стартовые дефолтные параметры
+        // default parameters to begin with
         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) || {});
+            itemParams = Object.assign(itemParams, ((_b = itemsStateAndParams === null || itemsStateAndParams === void 0 ? void 0 : itemsStateAndParams[id]) === null || _b === void 0 ? void 0 : _b.params) || {});
         }
         else {
-            itemParams = Object.assign(itemParams, 
-            // Параметры согласно очереди применения параметров
-            queueData.reduce((queueParams, data) => {
+            // params according to queue of its applying
+            let prevQueueDataWithActionParams = {};
+            let queueDataItems = {};
+            for (const data of Object.values(queueData)) {
                 if (data.namespace !== namespace || itemIgnores.includes(data.id)) {
-                    return queueParams;
+                    continue;
+                }
+                let actionParams;
+                let params = data.params;
+                const needAliasesForActionParams = data.id !== id && hasActionParam(data.params);
+                if (needAliasesForActionParams) {
+                    actionParams = pickActionParamsFromParams(data.params);
+                    params = pickExceptActionParamsFromParams(data.params);
+                }
+                const mergedParams = getMergedParams(params, actionParams);
+                const actionParamKeyToClear = intersection(Object.keys(transformParamsToActionParams(mergedParams)), Object.keys(prevQueueDataWithActionParams));
+                let queueDataRes = Object.assign({}, queueDataItems);
+                if (actionParamKeyToClear.length) {
+                    queueDataRes = omit(queueDataItems, actionParamKeyToClear);
                 }
-                return Object.assign(Object.assign({}, queueParams), getMergedParams(data.params));
-            }, {}));
+                queueDataItems = Object.assign(Object.assign({}, queueDataRes), mergedParams);
+                prevQueueDataWithActionParams = hasActionParam(queueDataItems)
+                    ? pickActionParamsFromParams(data.params, true)
+                    : {};
+            }
+            const clearActionParams = getDefaultsActionParamsToClear({
+                defaultWidgetParams,
+                queueWidgetParams: queueDataItems,
+            });
+            if (clearActionParams.length) {
+                defaultWidgetParams = omit(defaultWidgetParams, clearActionParams);
+            }
+            itemParams = Object.assign(itemParams, queueDataItems);
         }
-        return Object.assign(Object.assign({}, itemsParams), { [id]: itemParams });
+        return Object.assign(Object.assign({}, itemsParams), { [id]: Object.assign(Object.assign({}, defaultWidgetParams), itemParams) });
     }, {});
 }
 export function getItemsState({ config, itemsStateAndParams, }) {