@gravity-ui/dashkit 3.0.1

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

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

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

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

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

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

package/build/esm/shared/index.d.ts

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

package/build/esm/shared/index.js

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

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

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

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

@@ -0,0 +1,215 @@
+import { META_KEY } from '../../constants';
+import { formQueueData } from '../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',
+                    },
+                },
+                [META_KEY]: {
+                    queue: [{ id: DEFAULT_CONTROL_ID }],
+                    version: 2,
+                },
+            };
+            const controlItem1 = getMockedControlItem({ id: 'control-1' });
+            expect([]).toEqual(formQueueData({ items: [controlItem1], itemsStateAndParams }));
+            const controlItem2 = getMockedControlItem({ id: 'control-2', defaults: { scale: 'm' } });
+            expect([]).toEqual(formQueueData({ items: [controlItem2], itemsStateAndParams }));
+            const controlItem3 = getMockedControlItem({ defaults: { number: 'one', size: 's' } });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: {},
+                },
+            ]).toEqual(formQueueData({ items: [controlItem3], itemsStateAndParams }));
+            const controlItem4 = getMockedControlItem({ defaults: { scale: 'm', size: 's' } });
+            expect([
+                {
+                    id: DEFAULT_CONTROL_ID,
+                    namespace: NAMESPACE,
+                    params: { scale: 'd' },
+                },
+            ]).toEqual(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(formQueueData({ items: [controlItem5], itemsStateAndParams }));
+        });
+        it('return correct queue data for widget: common', () => {
+            const itemsStateAndParams = {
+                [DEFAULT_WIDGET_ID]: {
+                    params: {
+                        scale: 'd',
+                        view: 'normal',
+                    },
+                },
+                [META_KEY]: {
+                    queue: [{ id: DEFAULT_WIDGET_ID, tabId: DEFAULT_WIDGET_TAB_ID }],
+                    version: 2,
+                },
+            };
+            const widgetItem1 = getMockedWidgetItem({ id: 'widget-1' });
+            expect([]).toEqual(formQueueData({ items: [widgetItem1], itemsStateAndParams }));
+            const widgetItem2 = getMockedWidgetItem({
+                id: 'widget-2',
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID, params: { scale: 'm' } }],
+            });
+            expect([]).toEqual(formQueueData({ items: [widgetItem2], itemsStateAndParams }));
+            const widgetItem3 = getMockedWidgetItem({
+                tabs: [{ id: 'widget-3-tabId', params: { scale: 'm' } }],
+            });
+            expect([]).toEqual(formQueueData({ items: [widgetItem3], itemsStateAndParams }));
+            const widgetItem4 = getMockedWidgetItem({
+                tabs: [{ id: DEFAULT_WIDGET_TAB_ID }],
+            });
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: {},
+                },
+            ]).toEqual(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(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 },
+                },
+                [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 },
+                },
+                [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' },
+                },
+                [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(formQueueData({ items: [widgetItem], itemsStateAndParams: itemsStateAndParams1 }));
+            expect([
+                {
+                    id: DEFAULT_WIDGET_ID,
+                    namespace: NAMESPACE,
+                    params: { view: 'normal' },
+                },
+            ]).toEqual(formQueueData({ items: [widgetItem], itemsStateAndParams: itemsStateAndParams2 }));
+            expect([]).toEqual(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',
+                    },
+                },
+                [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(formQueueData({
+                items: [widgetItem2, widgetItem3, control1, widgetItem1, control2],
+                itemsStateAndParams,
+            }));
+        });
+    });
+});

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

@@ -0,0 +1,157 @@
+import keyBy from 'lodash/keyBy';
+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';
+function getNormalizedPlugins(plugins) {
+    return keyBy(plugins, 'type');
+}
+export 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;
+    });
+}
+export function getItemsStateAndParamsMeta(itemsStateAndParams) {
+    const meta = itemsStateAndParams === null || itemsStateAndParams === void 0 ? void 0 : itemsStateAndParams[META_KEY];
+    return meta;
+}
+export function getCurrentVersion(itemsStateAndParams) {
+    if (isEmpty(itemsStateAndParams)) {
+        return 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 CURRENT_VERSION;
+    }
+    return meta.version;
+}
+function nonNullable(value) {
+    return value !== null && value !== undefined;
+}
+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);
+}
+// Массив параметров, которые исходят от виджетов, согласно очереди
+export function formQueueData({ items, itemsStateAndParams, }) {
+    var _a;
+    const queue = ((_a = getItemsStateAndParamsMeta(itemsStateAndParams)) === null || _a === void 0 ? void 0 : _a.queue) || [];
+    const keyById = keyBy(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 = get(itemsStateAndParams, [item.id, 'params'], {});
+        return {
+            id: item.id,
+            namespace: item.namespace,
+            params: pick(itemQueueParams, Object.keys(itemDefaultParams)),
+        };
+    })
+        .filter(nonNullable);
+}
+export 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;
+}
+// В config.connections в from/to может быть как id item'a (item.id), так и id таба (item.data.tabs[].id)
+// Тут мы нормализуем к виду Record<itemId: ignoredItemId[]>
+export 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 = invert(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]) });
+    }, {});
+}
+export function mergeParamsWithAliases({ aliases, namespace, params, }) {
+    const aliasesByNamespace = get(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 });
+        }, {}));
+    }, {});
+}
+export function getInitialItemsStateAndParamsMeta() {
+    return {
+        queue: [],
+        version: CURRENT_VERSION,
+    };
+}
+export function addToQueue({ id, tabId, config, itemsStateAndParams, }) {
+    const queueItem = { id };
+    if (tabId) {
+        queueItem.tabId = tabId;
+    }
+    const meta = getItemsStateAndParamsMeta(itemsStateAndParams);
+    if (!meta) {
+        return { queue: [queueItem], version: 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 || CURRENT_VERSION,
+    };
+}
+export function deleteFromQueue(data) {
+    const meta = addToQueue(data);
+    return Object.assign(Object.assign({}, meta), { queue: meta.queue.slice(0, -1) });
+}

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

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

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

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

package/build/esm/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/esm/shared/modules/state-and-params.js

@@ -0,0 +1,87 @@
+import groupBy from 'lodash/groupBy';
+import { prerenderItems, formQueueData, getMapItemsIgnores, mergeParamsWithAliases, getCurrentVersion, } from './helpers';
+import { META_KEY } from '../constants';
+export function getItemsParams({ defaultGlobalParams = {}, globalParams = {}, config, itemsStateAndParams, plugins, }) {
+    const { aliases, connections } = config;
+    const items = prerenderItems({ items: config.items, plugins });
+    const isFirstVersion = getCurrentVersion(itemsStateAndParams) === 1;
+    const queueData = isFirstVersion
+        ? []
+        : formQueueData({ items, itemsStateAndParams });
+    // В будущем учитывать не только игноры, когда такой kind появится
+    const mapItemsIgnores = getMapItemsIgnores({
+        items,
+        ignores: connections.filter(({ kind }) => kind === 'ignore'),
+        itemsStateAndParams,
+        isFirstVersion,
+    });
+    const groupByNamespace = groupBy(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) => 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 });
+    }, {});
+}
+export 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;
+    }, {});
+}
+export 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 = getCurrentVersion(itemsStateAndParams);
+    if (version === 1) {
+        return result;
+    }
+    const meta = {
+        [META_KEY]: itemsStateAndParams[META_KEY],
+    };
+    return Object.assign(Object.assign({}, meta), result);
+}

package/build/esm/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/esm/shared/types/common.js

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

package/build/esm/shared/types/config.d.ts

@@ -0,0 +1,49 @@
+import { StringParams } from './common';
+export interface ConfigLayout {
+    i: string;
+    h: number;
+    w: number;
+    x: number;
+    y: number;
+}
+export interface ConfigItemData {
+    _editActive?: boolean;
+    tabs?: {
+        id: string;
+        isDefault?: boolean;
+        params?: StringParams;
+        [key: string]: unknown;
+    }[];
+    [key: string]: unknown;
+}
+export interface ConfigItemDataWithTabs extends Omit<ConfigItemData, 'tabs'> {
+    tabs: NonNullable<ConfigItemData['tabs']>;
+}
+export interface ConfigItem {
+    id: string;
+    data: ConfigItemData;
+    type: string;
+    namespace: string;
+    defaults?: StringParams;
+    orderId?: number;
+    defaultOrderId?: number;
+}
+export interface ConfigItemWithTabs extends Omit<ConfigItem, 'data'> {
+    data: ConfigItemDataWithTabs;
+}
+export interface ConfigAliases {
+    [namespace: string]: string[][];
+}
+export interface ConfigConnection {
+    from: string;
+    to: string;
+    kind: 'ignore';
+}
+export interface Config {
+    salt: string;
+    counter: number;
+    items: ConfigItem[];
+    layout: ConfigLayout[];
+    aliases: ConfigAliases;
+    connections: ConfigConnection[];
+}

package/build/esm/shared/types/config.js

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

package/build/esm/shared/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './config';
+export * from './state-and-params';
+export * from './plugin';

package/build/esm/shared/types/index.js

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './config';
+export * from './state-and-params';
+export * from './plugin';

package/build/esm/shared/types/plugin.d.ts

@@ -0,0 +1,8 @@
+import { ConfigItem } from './config';
+interface PluginSpecialFields {
+    prerenderMiddleware?: (item: ConfigItem) => ConfigItem;
+}
+export interface PluginBase extends PluginSpecialFields {
+    type: string;
+}
+export {};

package/build/esm/shared/types/plugin.js

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

package/build/esm/shared/types/state-and-params.d.ts

@@ -0,0 +1,22 @@
+import { META_KEY } from '../constants';
+import { StringParams } from './common';
+export interface ItemState {
+    [key: string]: any;
+}
+export interface QueueItem {
+    id: string;
+    tabId?: string;
+}
+export declare type StateAndParamsMetaData = {
+    queue: QueueItem[];
+    version: number;
+};
+export declare type StateAndParamsMeta = {
+    [META_KEY]: StateAndParamsMetaData;
+};
+export declare type ItemStateAndParams = {
+    params?: StringParams;
+    state?: ItemState;
+};
+export declare type ItemsStateAndParamsBase = Record<string, ItemStateAndParams>;
+export declare type ItemsStateAndParams = ItemsStateAndParamsBase | StateAndParamsMeta;

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

@@ -0,0 +1 @@
+import { META_KEY } from '../constants';