@gravity-ui/dashkit 5.2.0 → 5.4.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [5.4.0](https://github.com/gravity-ui/dashkit/compare/v5.3.0...v5.4.0) (2023-04-13)
+
+
+### Features
+
+* add widget defaults ([#52](https://github.com/gravity-ui/dashkit/issues/52)) ([a6e512d](https://github.com/gravity-ui/dashkit/commit/a6e512d132e6c9f0fc93d63527f233656863831e))
+* clear default actionParams ([#55](https://github.com/gravity-ui/dashkit/issues/55)) ([4184b82](https://github.com/gravity-ui/dashkit/commit/4184b828228c6faae21a9c9731fee544f7dd5362))
+
+## [5.3.0](https://github.com/gravity-ui/dashkit/compare/v5.2.0...v5.3.0) (2023-04-06)
+
+
+### Features
+
+* add actionParams support ([#47](https://github.com/gravity-ui/dashkit/issues/47)) ([0c78ae2](https://github.com/gravity-ui/dashkit/commit/0c78ae2b96d9882ea27a7e7742d40728fadcfa84))
+
 ## [5.2.0](https://github.com/gravity-ui/dashkit/compare/v5.1.0...v5.2.0) (2023-03-27)
 
 

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

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

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

@@ -13,6 +13,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: {
+        [`${constants_1.ACTION_PARAM_PREFIX}param1`]: 'val 1',
+        [`${constants_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 },
@@ -214,4 +267,28 @@ describe('modules.helpers', () => {
             }));
         });
     });
+    describe('actionParams helpers', () => {
+        it('check hasActionParams', () => {
+            const empty = (0, helpers_1.hasActionParams)({});
+            expect(empty).toBeFalsy();
+            const withParamsOnly = (0, helpers_1.hasActionParams)(stateAndParamsWithParamsOnly);
+            expect(withParamsOnly).toBeFalsy();
+            const withStateOnly = (0, helpers_1.hasActionParams)(stateAndParamsWithStateOnly);
+            expect(withStateOnly).toBeFalsy();
+            const withAPinParams = (0, helpers_1.hasActionParams)(stateAndParamsWithActionParamsInParamsOnly);
+            expect(withAPinParams).toBeTruthy();
+            const withAPinParamsNState = (0, helpers_1.hasActionParams)(stateAndParamsWithStateAndActionParamsInParams);
+            expect(withAPinParamsNState).toBeTruthy();
+            const withParamsAndAPinParams = (0, helpers_1.hasActionParams)(stateAndParamsWithParamsAndActionParamsInParams);
+            expect(withParamsAndAPinParams).toBeTruthy();
+        });
+        it('check transformParamsToActionParams', () => {
+            expect(paramsToTransform.out).toEqual((0, helpers_1.transformParamsToActionParams)(paramsToTransform.in));
+        });
+        it('check pickExceptActionParamsFromParams', () => {
+            expect(exeptActionParam1.out).toEqual((0, helpers_1.pickExceptActionParamsFromParams)(exeptActionParam1.in));
+            expect(exeptActionParam2.out).toEqual((0, helpers_1.pickExceptActionParamsFromParams)(exeptActionParam2.in));
+            expect(exeptActionParam3.out).toEqual((0, helpers_1.pickExceptActionParamsFromParams)(exeptActionParam3.in));
+        });
+    });
 });

package/build/cjs/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/cjs/shared/modules/helpers.js

@@ -1,12 +1,13 @@
 "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;
+exports.getDefaultsActionParamsToClear = exports.hasActionParams = exports.hasActionParam = exports.transformParamsToActionParams = exports.pickExceptActionParamsFromParams = exports.pickActionParamsFromParams = 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 intersection_1 = tslib_1.__importDefault(require("lodash/intersection"));
 const constants_1 = require("../constants");
 function getNormalizedPlugins(plugins) {
     return (0, keyBy_1.default)(plugins, 'type');
@@ -52,7 +53,7 @@ function isItemWithTabs(item) {
     return Array.isArray((_a = item === null || item === void 0 ? void 0 : item.data) === null || _a === void 0 ? void 0 : _a.tabs);
 }
 exports.isItemWithTabs = isItemWithTabs;
-// Массив параметров, которые исходят от виджетов, согласно очереди
+// Array of parameters from widgets according to queue
 function formQueueData({ items, itemsStateAndParams, }) {
     var _a;
     const queue = ((_a = getItemsStateAndParamsMeta(itemsStateAndParams)) === null || _a === void 0 ? void 0 : _a.queue) || [];
@@ -77,10 +78,24 @@ function formQueueData({ items, itemsStateAndParams, }) {
             itemDefaultParams = item.defaults || {};
         }
         const itemQueueParams = (0, get_1.default)(itemsStateAndParams, [item.id, 'params'], {});
+        const filteredParamsByDefaults = (0, pick_1.default)(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 = (0, pick_1.default)(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: (0, pick_1.default)(itemQueueParams, Object.keys(itemDefaultParams)),
+            params,
         };
     })
         .filter(nonNullable);
@@ -125,10 +140,11 @@ function getMapItemsIgnores({ items, ignores, itemsStateAndParams, isFirstVersio
     }, {});
 }
 exports.getMapItemsIgnores = getMapItemsIgnores;
-function mergeParamsWithAliases({ aliases, namespace, params, }) {
+function mergeParamsWithAliases({ aliases, namespace, params, actionParams, }) {
     const aliasesByNamespace = (0, get_1.default)(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]);
@@ -170,3 +186,97 @@ function deleteFromQueue(data) {
     return Object.assign(Object.assign({}, meta), { queue: meta.queue.slice(0, -1) });
 }
 exports.deleteFromQueue = deleteFromQueue;
+/**
+ * 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'}
+ */
+function pickActionParamsFromParams(params, returnWithPrefix) {
+    if (!params || (0, isEmpty_1.default)(params)) {
+        return {};
+    }
+    const actionParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        // starts with actionParams prefix (from'_ap_')
+        if (key.startsWith(constants_1.ACTION_PARAM_PREFIX)) {
+            const paramName = returnWithPrefix ? key : key.slice(constants_1.ACTION_PARAM_PREFIX.length);
+            actionParams[paramName] = val;
+        }
+    }
+    return actionParams;
+}
+exports.pickActionParamsFromParams = pickActionParamsFromParams;
+/**
+ * public function for getting params from object without actionParams
+ * @param params
+ */
+function pickExceptActionParamsFromParams(params) {
+    if (!params || (0, isEmpty_1.default)(params)) {
+        return {};
+    }
+    const onlyParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        if (!key.startsWith(constants_1.ACTION_PARAM_PREFIX)) {
+            onlyParams[key] = val;
+        }
+    }
+    return onlyParams;
+}
+exports.pickExceptActionParamsFromParams = pickExceptActionParamsFromParams;
+/**
+ * public function for transforming object to actionParams format
+ * @param params
+ */
+function transformParamsToActionParams(params) {
+    if (!params || (0, isEmpty_1.default)(params)) {
+        return {};
+    }
+    const actionParams = {};
+    for (const [key, val] of Object.entries(params)) {
+        actionParams[`${constants_1.ACTION_PARAM_PREFIX}${key}`] = val;
+    }
+    return actionParams;
+}
+exports.transformParamsToActionParams = transformParamsToActionParams;
+/**
+ * check if object contains actionParams
+ * @param conf
+ */
+function hasActionParam(conf) {
+    return Object.keys(conf || {}).some((key) => key.startsWith(constants_1.ACTION_PARAM_PREFIX));
+}
+exports.hasActionParam = hasActionParam;
+/**
+ * check if ItemStateAndParams object has actionParams in params or state field
+ * @param stateAndParams
+ */
+function hasActionParams(stateAndParams) {
+    if (!stateAndParams || (0, isEmpty_1.default)(stateAndParams)) {
+        return false;
+    }
+    return hasActionParam(stateAndParams.params);
+}
+exports.hasActionParams = hasActionParams;
+/**
+ * Collect array of actionParams keys with prefix (_ap_) that must be cleared from widget defaults
+ * @param defaultWidgetParams
+ * @param queueWidgetParams
+ */
+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 = (0, intersection_1.default)(Object.keys(queueWidgetParams), Object.keys(widgetDefaultsWithActionParams));
+    return actionParamKeyToClear.length
+        ? actionParamKeyToClear.map((key) => `${constants_1.ACTION_PARAM_PREFIX}${key}`)
+        : [];
+}
+exports.getDefaultsActionParamsToClear = getDefaultsActionParamsToClear;

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

@@ -3,8 +3,10 @@ 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 intersection_1 = tslib_1.__importDefault(require("lodash/intersection"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
 const constants_1 = require("../constants");
+const helpers_1 = require("./helpers");
 function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, itemsStateAndParams, plugins, }) {
     const { aliases, connections } = config;
     const items = (0, helpers_1.prerenderItems)({ items: config.items, plugins });
@@ -12,7 +14,7 @@ function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, i
     const queueData = isFirstVersion
         ? []
         : (0, helpers_1.formQueueData)({ items, itemsStateAndParams });
-    // В будущем учитывать не только игноры, когда такой kind появится
+    // to consider other kind types in future (not only ignore)
     const mapItemsIgnores = (0, helpers_1.getMapItemsIgnores)({
         items,
         ignores: connections.filter(({ kind }) => kind === 'ignore'),
@@ -22,35 +24,70 @@ function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, i
     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
-            // но определиться с порядком их применения
+            // 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) => (0, helpers_1.mergeParamsWithAliases)({ aliases, namespace, params: params || {} });
+        let defaultWidgetParams = {};
+        if ((0, helpers_1.isItemWithTabs)(item)) {
+            const currentWidgetTabId = (0, helpers_1.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) => (0, helpers_1.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 && (0, helpers_1.hasActionParam)(data.params);
+                if (needAliasesForActionParams) {
+                    actionParams = (0, helpers_1.pickActionParamsFromParams)(data.params);
+                    params = (0, helpers_1.pickExceptActionParamsFromParams)(data.params);
+                }
+                const mergedParams = getMergedParams(params, actionParams);
+                const actionParamKeyToClear = (0, intersection_1.default)(Object.keys((0, helpers_1.transformParamsToActionParams)(mergedParams)), Object.keys(prevQueueDataWithActionParams));
+                let queueDataRes = Object.assign({}, queueDataItems);
+                if (actionParamKeyToClear.length) {
+                    queueDataRes = (0, omit_1.default)(queueDataItems, actionParamKeyToClear);
                 }
-                return Object.assign(Object.assign({}, queueParams), getMergedParams(data.params));
-            }, {}));
+                queueDataItems = Object.assign(Object.assign({}, queueDataRes), mergedParams);
+                prevQueueDataWithActionParams = (0, helpers_1.hasActionParam)(queueDataItems)
+                    ? (0, helpers_1.pickActionParamsFromParams)(data.params, true)
+                    : {};
+            }
+            const clearActionParams = (0, helpers_1.getDefaultsActionParamsToClear)({
+                defaultWidgetParams,
+                queueWidgetParams: queueDataItems,
+            });
+            if (clearActionParams.length) {
+                defaultWidgetParams = (0, omit_1.default)(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) });
     }, {});
 }
 exports.getItemsParams = getItemsParams;

package/build/cjs/shared/units/__tests__/state-and-params.test.js

@@ -261,6 +261,155 @@ exports.stateAndParams3 = {
         },
     },
 };
+const stateAndParamsForAP1 = {
+    in: {
+        Q8: { params: { _ap_Country: 'Italy' } },
+        __meta__: { queue: [{ id: 'Q8', tabId: 'K0' }], version: 2 },
+    },
+    out: {
+        L5: {
+            params: { Country: 'Italy', 'd079937f-6bc4-4133-9171-40092bb20d6f': 'Italy' },
+            state: {},
+        },
+        Q8: {
+            params: {
+                Country: '',
+                Year: '',
+                _ap_Country: 'Italy',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+        al: {
+            params: { Country: 'Italy', 'd079937f-6bc4-4133-9171-40092bb20d6f': 'Italy' },
+            state: {},
+        },
+    },
+};
+const stateAndParamsForAP2 = {
+    in: {
+        L5: {
+            params: { 'd079937f-6bc4-4133-9171-40092bb20d6f': 'Belgium' },
+        },
+        Q8: {
+            params: { _ap_Country: 'Italy' },
+        },
+        __meta__: { queue: [{ id: 'Q8', tabId: 'K0' }, { id: 'L5' }], version: 2 },
+    },
+    out: {
+        L5: {
+            params: { Country: 'Belgium', 'd079937f-6bc4-4133-9171-40092bb20d6f': 'Belgium' },
+            state: {},
+        },
+        Q8: {
+            params: {
+                Country: 'Belgium',
+                Year: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': 'Belgium',
+            },
+            state: {},
+        },
+        al: {
+            params: { Country: 'Belgium', 'd079937f-6bc4-4133-9171-40092bb20d6f': 'Belgium' },
+            state: {},
+        },
+    },
+};
+const stateAndParamsForAP3 = {
+    in: {
+        Q8: { params: { _ap_Country: 'Italy' } },
+        L5: { params: { 'd079937f-6bc4-4133-9171-40092bb20d6f': '' } },
+        __meta__: { queue: [{ id: 'Q8', tabId: 'K0' }, { id: 'L5' }], version: 2 },
+    },
+    out: {
+        L5: {
+            params: {
+                Country: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+        Q8: {
+            params: {
+                Country: '',
+                Year: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+        al: {
+            params: {
+                Country: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+    },
+};
+const stateAndParamsForAP4 = {
+    in: {
+        Q8: { params: { _ap_Country: '' } },
+        L5: { params: { 'd079937f-6bc4-4133-9171-40092bb20d6f': '' } },
+        __meta__: { queue: [{ id: 'L5' }, { id: 'Q8', tabId: 'K0' }], version: 2 },
+    },
+    out: {
+        L5: {
+            params: {
+                Country: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+        Q8: {
+            params: {
+                Country: '',
+                Year: '',
+                _ap_Country: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+        al: {
+            params: {
+                Country: '',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': '',
+            },
+            state: {},
+        },
+    },
+};
+const stateAndParamsForAP5 = {
+    in: {
+        Q8: { params: {} },
+        L5: { params: {} },
+        __meta__: { queue: [], version: 2 },
+    },
+    out: {
+        L5: {
+            params: {
+                Country: ['Italy', 'France'],
+                'd079937f-6bc4-4133-9171-40092bb20d6f': ['Italy', 'France'],
+            },
+            state: {},
+        },
+        Q8: {
+            params: {
+                Country: ['Italy', 'France'],
+                Year: '',
+                _ap_Country: 'Belgium',
+                'd079937f-6bc4-4133-9171-40092bb20d6f': ['Italy', 'France'],
+            },
+            state: {},
+        },
+        al: {
+            params: {
+                Country: ['Italy', 'France'],
+                'd079937f-6bc4-4133-9171-40092bb20d6f': ['Italy', 'France'],
+            },
+            state: {},
+        },
+    },
+};
 const configs = configs_json_1.default.configs;
 describe('getItemsStateAndParamsDL', () => {
     describe('old version fallback', () => {
@@ -297,3 +446,60 @@ describe('getItemsStateAndParamsDL', () => {
         });
     });
 });
+describe('getItemsStateAndParams actionParams variants check', () => {
+    describe('action and params state 1', () => {
+        const resultItemsStateAndParams = (0, datalens_1.getItemsStateAndParamsDL)({
+            defaultGlobalParams: {},
+            globalParams: {},
+            config: configs[2],
+            itemsStateAndParams: stateAndParamsForAP1.in,
+        });
+        it('return stateAndParamsForAP1.out', () => {
+            expect(resultItemsStateAndParams).toEqual((0, omit_1.default)(stateAndParamsForAP1.out, constants_1.META_KEY));
+        });
+    });
+    describe('action and params state 2', () => {
+        const resultItemsStateAndParams = (0, datalens_1.getItemsStateAndParamsDL)({
+            defaultGlobalParams: {},
+            globalParams: {},
+            config: configs[2],
+            itemsStateAndParams: stateAndParamsForAP2.in,
+        });
+        it('return stateAndParamsForAP2.out', () => {
+            expect(resultItemsStateAndParams).toEqual((0, omit_1.default)(stateAndParamsForAP2.out, constants_1.META_KEY));
+        });
+    });
+    describe('action and params state 3', () => {
+        const resultItemsStateAndParams = (0, datalens_1.getItemsStateAndParamsDL)({
+            defaultGlobalParams: {},
+            globalParams: {},
+            config: configs[2],
+            itemsStateAndParams: stateAndParamsForAP3.in,
+        });
+        it('return stateAndParamsForAP3.out', () => {
+            expect(resultItemsStateAndParams).toEqual((0, omit_1.default)(stateAndParamsForAP3.out, constants_1.META_KEY));
+        });
+    });
+    describe('action and params state 4', () => {
+        const resultItemsStateAndParams = (0, datalens_1.getItemsStateAndParamsDL)({
+            defaultGlobalParams: {},
+            globalParams: {},
+            config: configs[2],
+            itemsStateAndParams: stateAndParamsForAP4.in,
+        });
+        it('return stateAndParamsForAP4.out', () => {
+            expect(resultItemsStateAndParams).toEqual((0, omit_1.default)(stateAndParamsForAP4.out, constants_1.META_KEY));
+        });
+    });
+    describe('action and params state 5', () => {
+        const resultItemsStateAndParams = (0, datalens_1.getItemsStateAndParamsDL)({
+            defaultGlobalParams: {},
+            globalParams: {},
+            config: configs[3],
+            itemsStateAndParams: stateAndParamsForAP5.in,
+        });
+        it('return stateAndParamsForAP5.out', () => {
+            expect(resultItemsStateAndParams).toEqual((0, omit_1.default)(stateAndParamsForAP5.out, constants_1.META_KEY));
+        });
+    });
+});