@tramvai/module-common 2.70.1 → 2.72.3

package/lib/command/defaultLines.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+
+const command = {
+    init: [core.commandLineListTokens.init, core.commandLineListTokens.listen],
+    close: [core.commandLineListTokens.close],
+    customer: [
+        core.commandLineListTokens.customerStart,
+        core.commandLineListTokens.resolveUserDeps,
+        core.commandLineListTokens.resolvePageDeps,
+        core.commandLineListTokens.generatePage,
+        core.commandLineListTokens.clear,
+    ],
+    spa: [
+        core.commandLineListTokens.resolveUserDeps,
+        core.commandLineListTokens.resolvePageDeps,
+        core.commandLineListTokens.spaTransition,
+    ],
+    afterSpa: [core.commandLineListTokens.afterSpaTransition],
+};
+const lines = {
+    server: command,
+    client: command,
+};
+
+exports.lines = lines;

package/lib/componentRegistry/componentRegistry.browser.js

@@ -0,0 +1,25 @@
+import pathOr from '@tinkoff/utils/object/pathOr';
+import flatten from '@tinkoff/utils/array/flatten';
+
+const DEFAULT_GROUP = '__default';
+class ComponentRegistry {
+    constructor({ componentList } = {}) {
+        this.components = {
+            [DEFAULT_GROUP]: Object.assign({}, ...flatten(componentList !== null && componentList !== void 0 ? componentList : [])),
+        };
+    }
+    add(name, component, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        groupComponents[name] = component;
+        this.components[group] = groupComponents;
+    }
+    get(name, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        return groupComponents[name] || this.components[DEFAULT_GROUP][name];
+    }
+    getComponentParam(param, defaultValue, component, group) {
+        return pathOr([param], defaultValue, this.get(component, group));
+    }
+}
+
+export { ComponentRegistry };

package/lib/componentRegistry/componentRegistry.es.js

@@ -0,0 +1,25 @@
+import pathOr from '@tinkoff/utils/object/pathOr';
+import flatten from '@tinkoff/utils/array/flatten';
+
+const DEFAULT_GROUP = '__default';
+class ComponentRegistry {
+    constructor({ componentList } = {}) {
+        this.components = {
+            [DEFAULT_GROUP]: Object.assign({}, ...flatten(componentList !== null && componentList !== void 0 ? componentList : [])),
+        };
+    }
+    add(name, component, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        groupComponents[name] = component;
+        this.components[group] = groupComponents;
+    }
+    get(name, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        return groupComponents[name] || this.components[DEFAULT_GROUP][name];
+    }
+    getComponentParam(param, defaultValue, component, group) {
+        return pathOr([param], defaultValue, this.get(component, group));
+    }
+}
+
+export { ComponentRegistry };

package/lib/componentRegistry/componentRegistry.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pathOr = require('@tinkoff/utils/object/pathOr');
+var flatten = require('@tinkoff/utils/array/flatten');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pathOr__default = /*#__PURE__*/_interopDefaultLegacy(pathOr);
+var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
+
+const DEFAULT_GROUP = '__default';
+class ComponentRegistry {
+    constructor({ componentList } = {}) {
+        this.components = {
+            [DEFAULT_GROUP]: Object.assign({}, ...flatten__default["default"](componentList !== null && componentList !== void 0 ? componentList : [])),
+        };
+    }
+    add(name, component, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        groupComponents[name] = component;
+        this.components[group] = groupComponents;
+    }
+    get(name, group = DEFAULT_GROUP) {
+        const groupComponents = this.components[group] || {};
+        return groupComponents[name] || this.components[DEFAULT_GROUP][name];
+    }
+    getComponentParam(param, defaultValue, component, group) {
+        return pathOr__default["default"]([param], defaultValue, this.get(component, group));
+    }
+}
+
+exports.ComponentRegistry = ComponentRegistry;

package/lib/createConsumerContext/createConsumerContext.browser.js

@@ -0,0 +1,62 @@
+import { convertAction } from '@tramvai/state';
+import { ACTION_EXECUTION_TOKEN } from '@tramvai/tokens-common';
+
+class ConsumerContext {
+    constructor({ di, dispatcherContext, pubsub, store }) {
+        /* Side Effects */
+        this.executeAction = (action, payload) => {
+            return this.di.get(ACTION_EXECUTION_TOKEN).run(action, payload);
+        };
+        /* State manager */
+        this.dispatch = (actionOrNameEvent, payload) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    resolve(this.store.dispatch(convertAction(actionOrNameEvent, payload)));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        };
+        this.dispatchWith = (createActionOrType, options) => {
+            return typeof createActionOrType === 'function'
+                ? (...args) => this.dispatch(createActionOrType(...args), options)
+                : (payload) => this.dispatch(createActionOrType, payload);
+        };
+        /**
+         * @deprecated
+         */
+        this.getStore = (store) => {
+            return this.dispatcher.getStore(store);
+        };
+        this.dehydrate = () => ({
+            dispatcher: this.dispatcher.dehydrate(),
+        });
+        this.getState = (...args) => {
+            return this.store.getState(args[0]);
+        };
+        this.subscribe = (...args) => {
+            return this.store.subscribe(args[0], args[1]);
+        };
+        this.hasStore = (store) => this.dispatcher.hasStore(store);
+        this.registerStore = (store) => this.dispatcher.registerStore(store);
+        this.unregisterStore = (store) => this.dispatcher.unregisterStore(store);
+        this.store = store;
+        // @ts-expect-error
+        this.dispatcher = dispatcherContext;
+        // TODO убрать, нужно для некоторых старых сторов на платформе
+        this.dispatcher.setContext(this);
+        this.di = di; // кажется этого здесь не  должно быть
+        this.pubsub = pubsub;
+    }
+}
+function createConsumerContext({ di, dispatcherContext, pubsub, store }) {
+    return new ConsumerContext({
+        di,
+        dispatcherContext,
+        pubsub,
+        store,
+    });
+}
+
+export { ConsumerContext, createConsumerContext };

package/lib/createConsumerContext/createConsumerContext.es.js

@@ -0,0 +1,62 @@
+import { convertAction } from '@tramvai/state';
+import { ACTION_EXECUTION_TOKEN } from '@tramvai/tokens-common';
+
+class ConsumerContext {
+    constructor({ di, dispatcherContext, pubsub, store }) {
+        /* Side Effects */
+        this.executeAction = (action, payload) => {
+            return this.di.get(ACTION_EXECUTION_TOKEN).run(action, payload);
+        };
+        /* State manager */
+        this.dispatch = (actionOrNameEvent, payload) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    resolve(this.store.dispatch(convertAction(actionOrNameEvent, payload)));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        };
+        this.dispatchWith = (createActionOrType, options) => {
+            return typeof createActionOrType === 'function'
+                ? (...args) => this.dispatch(createActionOrType(...args), options)
+                : (payload) => this.dispatch(createActionOrType, payload);
+        };
+        /**
+         * @deprecated
+         */
+        this.getStore = (store) => {
+            return this.dispatcher.getStore(store);
+        };
+        this.dehydrate = () => ({
+            dispatcher: this.dispatcher.dehydrate(),
+        });
+        this.getState = (...args) => {
+            return this.store.getState(args[0]);
+        };
+        this.subscribe = (...args) => {
+            return this.store.subscribe(args[0], args[1]);
+        };
+        this.hasStore = (store) => this.dispatcher.hasStore(store);
+        this.registerStore = (store) => this.dispatcher.registerStore(store);
+        this.unregisterStore = (store) => this.dispatcher.unregisterStore(store);
+        this.store = store;
+        // @ts-expect-error
+        this.dispatcher = dispatcherContext;
+        // TODO убрать, нужно для некоторых старых сторов на платформе
+        this.dispatcher.setContext(this);
+        this.di = di; // кажется этого здесь не  должно быть
+        this.pubsub = pubsub;
+    }
+}
+function createConsumerContext({ di, dispatcherContext, pubsub, store }) {
+    return new ConsumerContext({
+        di,
+        dispatcherContext,
+        pubsub,
+        store,
+    });
+}
+
+export { ConsumerContext, createConsumerContext };

package/lib/createConsumerContext/createConsumerContext.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var state = require('@tramvai/state');
+var tokensCommon = require('@tramvai/tokens-common');
+
+class ConsumerContext {
+    constructor({ di, dispatcherContext, pubsub, store }) {
+        /* Side Effects */
+        this.executeAction = (action, payload) => {
+            return this.di.get(tokensCommon.ACTION_EXECUTION_TOKEN).run(action, payload);
+        };
+        /* State manager */
+        this.dispatch = (actionOrNameEvent, payload) => {
+            return new Promise((resolve, reject) => {
+                try {
+                    resolve(this.store.dispatch(state.convertAction(actionOrNameEvent, payload)));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        };
+        this.dispatchWith = (createActionOrType, options) => {
+            return typeof createActionOrType === 'function'
+                ? (...args) => this.dispatch(createActionOrType(...args), options)
+                : (payload) => this.dispatch(createActionOrType, payload);
+        };
+        /**
+         * @deprecated
+         */
+        this.getStore = (store) => {
+            return this.dispatcher.getStore(store);
+        };
+        this.dehydrate = () => ({
+            dispatcher: this.dispatcher.dehydrate(),
+        });
+        this.getState = (...args) => {
+            return this.store.getState(args[0]);
+        };
+        this.subscribe = (...args) => {
+            return this.store.subscribe(args[0], args[1]);
+        };
+        this.hasStore = (store) => this.dispatcher.hasStore(store);
+        this.registerStore = (store) => this.dispatcher.registerStore(store);
+        this.unregisterStore = (store) => this.dispatcher.unregisterStore(store);
+        this.store = store;
+        // @ts-expect-error
+        this.dispatcher = dispatcherContext;
+        // TODO убрать, нужно для некоторых старых сторов на платформе
+        this.dispatcher.setContext(this);
+        this.di = di; // кажется этого здесь не  должно быть
+        this.pubsub = pubsub;
+    }
+}
+function createConsumerContext({ di, dispatcherContext, pubsub, store }) {
+    return new ConsumerContext({
+        di,
+        dispatcherContext,
+        pubsub,
+        store,
+    });
+}
+
+exports.ConsumerContext = ConsumerContext;
+exports.createConsumerContext = createConsumerContext;

package/lib/executionContext/executionContextManager.browser.js

@@ -0,0 +1,57 @@
+import { ExecutionAbortError } from '@tinkoff/errors';
+import { AbortController } from 'node-abort-controller';
+
+const EMPTY_VALUES = {};
+const normalizeOptions = (nameOrOptions) => {
+    return typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
+};
+class ExecutionContextManager {
+    async withContext(parentContext, nameOrOptions, cb) {
+        const options = normalizeOptions(nameOrOptions);
+        const { name, values: selfValues = EMPTY_VALUES } = options;
+        const contextName = parentContext ? `${parentContext.name}.${name}` : name;
+        if (parentContext === null || parentContext === void 0 ? void 0 : parentContext.abortSignal.aborted) {
+            throw new ExecutionAbortError({
+                message: `Execution aborted in context "${contextName}"`,
+                contextName,
+            });
+        }
+        const abortController = new AbortController();
+        let abortListener;
+        let values = selfValues;
+        if (parentContext) {
+            values = {
+                ...parentContext.values,
+                ...selfValues,
+            };
+            abortListener = () => {
+                abortController.abort();
+            };
+            // abort child context AbortController if parent AbortController was aborted
+            parentContext.abortSignal.addEventListener('abort', abortListener);
+        }
+        const context = {
+            name: contextName,
+            abortSignal: abortController.signal,
+            values,
+        };
+        try {
+            const result = await cb(context, abortController);
+            return result;
+        }
+        catch (error) {
+            if (typeof error === 'object' && !error.executionContextName) {
+                error.executionContextName = context.name;
+            }
+            throw error;
+        }
+        finally {
+            // @ts-expect-error
+            if (abortListener && parentContext) {
+                parentContext.abortSignal.removeEventListener('abort', abortListener);
+            }
+        }
+    }
+}
+
+export { ExecutionContextManager };

package/lib/executionContext/executionContextManager.es.js

@@ -0,0 +1,57 @@
+import { ExecutionAbortError } from '@tinkoff/errors';
+import { AbortController } from 'node-abort-controller';
+
+const EMPTY_VALUES = {};
+const normalizeOptions = (nameOrOptions) => {
+    return typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
+};
+class ExecutionContextManager {
+    async withContext(parentContext, nameOrOptions, cb) {
+        const options = normalizeOptions(nameOrOptions);
+        const { name, values: selfValues = EMPTY_VALUES } = options;
+        const contextName = parentContext ? `${parentContext.name}.${name}` : name;
+        if (parentContext === null || parentContext === void 0 ? void 0 : parentContext.abortSignal.aborted) {
+            throw new ExecutionAbortError({
+                message: `Execution aborted in context "${contextName}"`,
+                contextName,
+            });
+        }
+        const abortController = new AbortController();
+        let abortListener;
+        let values = selfValues;
+        if (parentContext) {
+            values = {
+                ...parentContext.values,
+                ...selfValues,
+            };
+            abortListener = () => {
+                abortController.abort();
+            };
+            // abort child context AbortController if parent AbortController was aborted
+            parentContext.abortSignal.addEventListener('abort', abortListener);
+        }
+        const context = {
+            name: contextName,
+            abortSignal: abortController.signal,
+            values,
+        };
+        try {
+            const result = await cb(context, abortController);
+            return result;
+        }
+        catch (error) {
+            if (typeof error === 'object' && !error.executionContextName) {
+                error.executionContextName = context.name;
+            }
+            throw error;
+        }
+        finally {
+            // @ts-expect-error
+            if (abortListener && parentContext) {
+                parentContext.abortSignal.removeEventListener('abort', abortListener);
+            }
+        }
+    }
+}
+
+export { ExecutionContextManager };

package/lib/executionContext/executionContextManager.js

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('@tinkoff/errors');
+var nodeAbortController = require('node-abort-controller');
+
+const EMPTY_VALUES = {};
+const normalizeOptions = (nameOrOptions) => {
+    return typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
+};
+class ExecutionContextManager {
+    async withContext(parentContext, nameOrOptions, cb) {
+        const options = normalizeOptions(nameOrOptions);
+        const { name, values: selfValues = EMPTY_VALUES } = options;
+        const contextName = parentContext ? `${parentContext.name}.${name}` : name;
+        if (parentContext === null || parentContext === void 0 ? void 0 : parentContext.abortSignal.aborted) {
+            throw new errors.ExecutionAbortError({
+                message: `Execution aborted in context "${contextName}"`,
+                contextName,
+            });
+        }
+        const abortController = new nodeAbortController.AbortController();
+        let abortListener;
+        let values = selfValues;
+        if (parentContext) {
+            values = {
+                ...parentContext.values,
+                ...selfValues,
+            };
+            abortListener = () => {
+                abortController.abort();
+            };
+            // abort child context AbortController if parent AbortController was aborted
+            parentContext.abortSignal.addEventListener('abort', abortListener);
+        }
+        const context = {
+            name: contextName,
+            abortSignal: abortController.signal,
+            values,
+        };
+        try {
+            const result = await cb(context, abortController);
+            return result;
+        }
+        catch (error) {
+            if (typeof error === 'object' && !error.executionContextName) {
+                error.executionContextName = context.name;
+            }
+            throw error;
+        }
+        finally {
+            // @ts-expect-error
+            if (abortListener && parentContext) {
+                parentContext.abortSignal.removeEventListener('abort', abortListener);
+            }
+        }
+    }
+}
+
+exports.ExecutionContextManager = ExecutionContextManager;