@tramvai/module-common 2.70.1 → 2.72.3

package/lib/child-app/state.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokensCommon = require('@tramvai/tokens-common');
+
+const stateProviders = [
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN,
+        multi: true,
+        useValue: [tokensCommon.DISPATCHER_TOKEN, tokensCommon.STORE_TOKEN, tokensCommon.CONTEXT_TOKEN],
+    }),
+];
+
+exports.stateProviders = stateProviders;

package/lib/command/CommandModule.browser.js

@@ -0,0 +1,52 @@
+import { __decorate } from 'tslib';
+import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN } from '@tramvai/core';
+import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { provide, Scope } from '@tinkoff/dippy';
+import { CommandLineRunner } from './commandLineRunner.browser.js';
+import { lines } from './defaultLines.browser.js';
+
+let CommandModule = class CommandModule {
+};
+CommandModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                // Раннер процессов
+                provide: COMMAND_LINE_RUNNER_TOKEN,
+                scope: Scope.SINGLETON,
+                useClass: CommandLineRunner,
+                deps: {
+                    lines: COMMAND_LINES_TOKEN,
+                    rootDi: DI_TOKEN,
+                    logger: LOGGER_TOKEN,
+                    executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
+                    executionEndHandlers: {
+                        token: COMMAND_LINE_EXECUTION_END_TOKEN,
+                        optional: true,
+                    },
+                },
+            }),
+            provide({
+                provide: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                useFactory: ({ di, commandLineRunner }) => {
+                    return () => {
+                        return commandLineRunner.resolveExecutionContextFromDi(di);
+                    };
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
+                },
+            }),
+            provide({
+                // Дефолтный список команл
+                provide: COMMAND_LINES_TOKEN,
+                scope: Scope.SINGLETON,
+                useValue: lines,
+            }),
+        ],
+    })
+], CommandModule);
+
+export { CommandModule };

package/lib/command/CommandModule.es.js

@@ -0,0 +1,52 @@
+import { __decorate } from 'tslib';
+import { Module, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN } from '@tramvai/core';
+import { COMMAND_LINE_EXECUTION_END_TOKEN } from '@tramvai/tokens-core-private';
+import { LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { provide, Scope } from '@tinkoff/dippy';
+import { CommandLineRunner } from './commandLineRunner.es.js';
+import { lines } from './defaultLines.es.js';
+
+let CommandModule = class CommandModule {
+};
+CommandModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                // Раннер процессов
+                provide: COMMAND_LINE_RUNNER_TOKEN,
+                scope: Scope.SINGLETON,
+                useClass: CommandLineRunner,
+                deps: {
+                    lines: COMMAND_LINES_TOKEN,
+                    rootDi: DI_TOKEN,
+                    logger: LOGGER_TOKEN,
+                    executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
+                    executionEndHandlers: {
+                        token: COMMAND_LINE_EXECUTION_END_TOKEN,
+                        optional: true,
+                    },
+                },
+            }),
+            provide({
+                provide: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                useFactory: ({ di, commandLineRunner }) => {
+                    return () => {
+                        return commandLineRunner.resolveExecutionContextFromDi(di);
+                    };
+                },
+                deps: {
+                    di: DI_TOKEN,
+                    commandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
+                },
+            }),
+            provide({
+                // Дефолтный список команл
+                provide: COMMAND_LINES_TOKEN,
+                scope: Scope.SINGLETON,
+                useValue: lines,
+            }),
+        ],
+    })
+], CommandModule);
+
+export { CommandModule };

package/lib/command/CommandModule.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensCorePrivate = require('@tramvai/tokens-core-private');
+var tokensCommon = require('@tramvai/tokens-common');
+var dippy = require('@tinkoff/dippy');
+var commandLineRunner = require('./commandLineRunner.js');
+var defaultLines = require('./defaultLines.js');
+
+exports.CommandModule = class CommandModule {
+};
+exports.CommandModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            dippy.provide({
+                // Раннер процессов
+                provide: core.COMMAND_LINE_RUNNER_TOKEN,
+                scope: dippy.Scope.SINGLETON,
+                useClass: commandLineRunner.CommandLineRunner,
+                deps: {
+                    lines: core.COMMAND_LINES_TOKEN,
+                    rootDi: core.DI_TOKEN,
+                    logger: tokensCommon.LOGGER_TOKEN,
+                    executionContextManager: tokensCommon.EXECUTION_CONTEXT_MANAGER_TOKEN,
+                    executionEndHandlers: {
+                        token: tokensCorePrivate.COMMAND_LINE_EXECUTION_END_TOKEN,
+                        optional: true,
+                    },
+                },
+            }),
+            dippy.provide({
+                provide: tokensCommon.COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
+                useFactory: ({ di, commandLineRunner }) => {
+                    return () => {
+                        return commandLineRunner.resolveExecutionContextFromDi(di);
+                    };
+                },
+                deps: {
+                    di: core.DI_TOKEN,
+                    commandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
+                },
+            }),
+            dippy.provide({
+                // Дефолтный список команл
+                provide: core.COMMAND_LINES_TOKEN,
+                scope: dippy.Scope.SINGLETON,
+                useValue: defaultLines.lines,
+            }),
+        ],
+    })
+], exports.CommandModule);

package/lib/command/commandLineRunner.browser.js

@@ -0,0 +1,147 @@
+import { isSilentError } from '@tinkoff/errors';
+import { COMMAND_LINE_TIMING_INFO_TOKEN } from '@tramvai/tokens-core-private';
+import { createChildContainer } from '@tinkoff/dippy';
+import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+
+const resolveDi = (type, status, diContainer, providers) => {
+    let di = diContainer;
+    if (status === 'customer' && type !== 'client') {
+        di = createChildContainer(di);
+    }
+    if (providers) {
+        providers.forEach((item) => {
+            return di.register(item);
+        });
+    }
+    return di;
+};
+class CommandLineRunner {
+    constructor({ lines, rootDi, logger, executionContextManager, executionEndHandlers }) {
+        this.executionContextByDi = new WeakMap();
+        this.abortControllerByDi = new WeakMap();
+        this.lines = lines;
+        this.rootDi = rootDi;
+        this.log = logger('command:command-line-runner');
+        this.executionContextManager = executionContextManager;
+        this.executionEndHandlers = executionEndHandlers;
+    }
+    run(type, status, providers, customDi) {
+        const di = customDi !== null && customDi !== void 0 ? customDi : resolveDi(type, status, this.rootDi, providers);
+        const rootExecutionContext = di.get({ token: ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
+        this.log.debug({
+            event: 'command-run',
+            type,
+            status,
+        });
+        const timingInfo = {};
+        di.register({ provide: COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
+        return (this.lines[type][status]
+            .reduce((chain, line) => {
+            return chain.then(() => {
+                const lineName = line.toString();
+                timingInfo[lineName] = { start: performance.now() };
+                // eslint-disable-next-line promise/no-nesting
+                return Promise.resolve()
+                    .then(() => {
+                    return this.executionContextManager.withContext(rootExecutionContext, `command-line:${lineName}`, async (executionContext, abortController) => {
+                        this.executionContextByDi.set(di, executionContext);
+                        this.abortControllerByDi.set(di, abortController);
+                        await this.createLineChain(di, line);
+                    });
+                })
+                    .finally(() => {
+                    timingInfo[lineName].end = performance.now();
+                });
+            });
+        }, Promise.resolve())
+            // После завершения цепочки отдаем context выполнения
+            .finally(() => {
+            this.executionContextByDi.delete(di);
+            this.abortControllerByDi.delete(di);
+            if (this.executionEndHandlers) {
+                for (const executionEndHandler of this.executionEndHandlers) {
+                    executionEndHandler(di, type, status, timingInfo);
+                }
+            }
+        })
+            .then(() => di));
+    }
+    resolveExecutionContextFromDi(di) {
+        var _a;
+        return (_a = this.executionContextByDi.get(di)) !== null && _a !== void 0 ? _a : null;
+    }
+    createLineChain(di, line) {
+        let lineInstance;
+        try {
+            lineInstance = di.get({ token: line, optional: true });
+            // Пропускаем step. Так как нет действий
+            if (lineInstance === null) {
+                return Promise.resolve();
+            }
+        }
+        catch (e) {
+            // Логируем ошибку и дальше падаем
+            this.log.error(e);
+            return this.throwError(e, di);
+        }
+        if (!Array.isArray(lineInstance)) {
+            return this.instanceExecute(lineInstance, line, di);
+        }
+        return Promise.all(lineInstance.map((instance) => {
+            return this.instanceExecute(instance, line, di);
+        }));
+    }
+    instanceExecute(instance, line, di) {
+        if (!(instance instanceof Function)) {
+            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${line.toString()}", received "${instance}".
+      Check that all commandLineListTokens subscribers return functions`);
+            if (process.env.NODE_ENV !== 'production') {
+                const instances = di.get(line);
+                const record = di.getRecord(line.toString());
+                // пробегаемся по всем инстансам и для текущего получаем его запись, из которой можно получить стек
+                for (let i = 0; i < instances.length; i++) {
+                    if (instances[i] === instance) {
+                        // @ts-expect-error
+                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
+                    }
+                }
+            }
+            this.log.error({
+                event: 'line-error',
+                error,
+                line: line.toString(),
+            });
+            return;
+        }
+        const { name = '' } = instance;
+        this.log.debug({
+            event: 'line-run',
+            line: line.toString(),
+            command: name,
+        });
+        return Promise.resolve()
+            .then(() => instance())
+            .catch((err) => {
+            var _a;
+            this.log[isSilentError(err) ? 'debug' : 'error']({
+                event: 'line-error',
+                error: err,
+                line: line.toString(),
+                command: name,
+            });
+            // in case if any error happens during line execution results from other line handlers will not be used anyway
+            (_a = this.abortControllerByDi.get(di)) === null || _a === void 0 ? void 0 : _a.abort();
+            this.throwError(err, di);
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    throwError(err, di) {
+        if (typeof err === 'object') {
+            // eslint-disable-next-line no-param-reassign
+            err.di = di;
+        }
+        throw err;
+    }
+}
+
+export { CommandLineRunner };

package/lib/command/commandLineRunner.es.js

@@ -0,0 +1,147 @@
+import { isSilentError } from '@tinkoff/errors';
+import { COMMAND_LINE_TIMING_INFO_TOKEN } from '@tramvai/tokens-core-private';
+import { createChildContainer } from '@tinkoff/dippy';
+import { ROOT_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
+
+const resolveDi = (type, status, diContainer, providers) => {
+    let di = diContainer;
+    if (status === 'customer' && type !== 'client') {
+        di = createChildContainer(di);
+    }
+    if (providers) {
+        providers.forEach((item) => {
+            return di.register(item);
+        });
+    }
+    return di;
+};
+class CommandLineRunner {
+    constructor({ lines, rootDi, logger, executionContextManager, executionEndHandlers }) {
+        this.executionContextByDi = new WeakMap();
+        this.abortControllerByDi = new WeakMap();
+        this.lines = lines;
+        this.rootDi = rootDi;
+        this.log = logger('command:command-line-runner');
+        this.executionContextManager = executionContextManager;
+        this.executionEndHandlers = executionEndHandlers;
+    }
+    run(type, status, providers, customDi) {
+        const di = customDi !== null && customDi !== void 0 ? customDi : resolveDi(type, status, this.rootDi, providers);
+        const rootExecutionContext = di.get({ token: ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
+        this.log.debug({
+            event: 'command-run',
+            type,
+            status,
+        });
+        const timingInfo = {};
+        di.register({ provide: COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
+        return (this.lines[type][status]
+            .reduce((chain, line) => {
+            return chain.then(() => {
+                const lineName = line.toString();
+                timingInfo[lineName] = { start: performance.now() };
+                // eslint-disable-next-line promise/no-nesting
+                return Promise.resolve()
+                    .then(() => {
+                    return this.executionContextManager.withContext(rootExecutionContext, `command-line:${lineName}`, async (executionContext, abortController) => {
+                        this.executionContextByDi.set(di, executionContext);
+                        this.abortControllerByDi.set(di, abortController);
+                        await this.createLineChain(di, line);
+                    });
+                })
+                    .finally(() => {
+                    timingInfo[lineName].end = performance.now();
+                });
+            });
+        }, Promise.resolve())
+            // После завершения цепочки отдаем context выполнения
+            .finally(() => {
+            this.executionContextByDi.delete(di);
+            this.abortControllerByDi.delete(di);
+            if (this.executionEndHandlers) {
+                for (const executionEndHandler of this.executionEndHandlers) {
+                    executionEndHandler(di, type, status, timingInfo);
+                }
+            }
+        })
+            .then(() => di));
+    }
+    resolveExecutionContextFromDi(di) {
+        var _a;
+        return (_a = this.executionContextByDi.get(di)) !== null && _a !== void 0 ? _a : null;
+    }
+    createLineChain(di, line) {
+        let lineInstance;
+        try {
+            lineInstance = di.get({ token: line, optional: true });
+            // Пропускаем step. Так как нет действий
+            if (lineInstance === null) {
+                return Promise.resolve();
+            }
+        }
+        catch (e) {
+            // Логируем ошибку и дальше падаем
+            this.log.error(e);
+            return this.throwError(e, di);
+        }
+        if (!Array.isArray(lineInstance)) {
+            return this.instanceExecute(lineInstance, line, di);
+        }
+        return Promise.all(lineInstance.map((instance) => {
+            return this.instanceExecute(instance, line, di);
+        }));
+    }
+    instanceExecute(instance, line, di) {
+        if (!(instance instanceof Function)) {
+            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${line.toString()}", received "${instance}".
+      Check that all commandLineListTokens subscribers return functions`);
+            if (process.env.NODE_ENV !== 'production') {
+                const instances = di.get(line);
+                const record = di.getRecord(line.toString());
+                // пробегаемся по всем инстансам и для текущего получаем его запись, из которой можно получить стек
+                for (let i = 0; i < instances.length; i++) {
+                    if (instances[i] === instance) {
+                        // @ts-expect-error
+                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
+                    }
+                }
+            }
+            this.log.error({
+                event: 'line-error',
+                error,
+                line: line.toString(),
+            });
+            return;
+        }
+        const { name = '' } = instance;
+        this.log.debug({
+            event: 'line-run',
+            line: line.toString(),
+            command: name,
+        });
+        return Promise.resolve()
+            .then(() => instance())
+            .catch((err) => {
+            var _a;
+            this.log[isSilentError(err) ? 'debug' : 'error']({
+                event: 'line-error',
+                error: err,
+                line: line.toString(),
+                command: name,
+            });
+            // in case if any error happens during line execution results from other line handlers will not be used anyway
+            (_a = this.abortControllerByDi.get(di)) === null || _a === void 0 ? void 0 : _a.abort();
+            this.throwError(err, di);
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    throwError(err, di) {
+        if (typeof err === 'object') {
+            // eslint-disable-next-line no-param-reassign
+            err.di = di;
+        }
+        throw err;
+    }
+}
+
+export { CommandLineRunner };

package/lib/command/commandLineRunner.js

@@ -0,0 +1,151 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var errors = require('@tinkoff/errors');
+var tokensCorePrivate = require('@tramvai/tokens-core-private');
+var dippy = require('@tinkoff/dippy');
+var tokensCommon = require('@tramvai/tokens-common');
+
+const resolveDi = (type, status, diContainer, providers) => {
+    let di = diContainer;
+    if (status === 'customer' && type !== 'client') {
+        di = dippy.createChildContainer(di);
+    }
+    if (providers) {
+        providers.forEach((item) => {
+            return di.register(item);
+        });
+    }
+    return di;
+};
+class CommandLineRunner {
+    constructor({ lines, rootDi, logger, executionContextManager, executionEndHandlers }) {
+        this.executionContextByDi = new WeakMap();
+        this.abortControllerByDi = new WeakMap();
+        this.lines = lines;
+        this.rootDi = rootDi;
+        this.log = logger('command:command-line-runner');
+        this.executionContextManager = executionContextManager;
+        this.executionEndHandlers = executionEndHandlers;
+    }
+    run(type, status, providers, customDi) {
+        const di = customDi !== null && customDi !== void 0 ? customDi : resolveDi(type, status, this.rootDi, providers);
+        const rootExecutionContext = di.get({ token: tokensCommon.ROOT_EXECUTION_CONTEXT_TOKEN, optional: true });
+        this.log.debug({
+            event: 'command-run',
+            type,
+            status,
+        });
+        const timingInfo = {};
+        di.register({ provide: tokensCorePrivate.COMMAND_LINE_TIMING_INFO_TOKEN, useValue: timingInfo });
+        return (this.lines[type][status]
+            .reduce((chain, line) => {
+            return chain.then(() => {
+                const lineName = line.toString();
+                timingInfo[lineName] = { start: performance.now() };
+                // eslint-disable-next-line promise/no-nesting
+                return Promise.resolve()
+                    .then(() => {
+                    return this.executionContextManager.withContext(rootExecutionContext, `command-line:${lineName}`, async (executionContext, abortController) => {
+                        this.executionContextByDi.set(di, executionContext);
+                        this.abortControllerByDi.set(di, abortController);
+                        await this.createLineChain(di, line);
+                    });
+                })
+                    .finally(() => {
+                    timingInfo[lineName].end = performance.now();
+                });
+            });
+        }, Promise.resolve())
+            // После завершения цепочки отдаем context выполнения
+            .finally(() => {
+            this.executionContextByDi.delete(di);
+            this.abortControllerByDi.delete(di);
+            if (this.executionEndHandlers) {
+                for (const executionEndHandler of this.executionEndHandlers) {
+                    executionEndHandler(di, type, status, timingInfo);
+                }
+            }
+        })
+            .then(() => di));
+    }
+    resolveExecutionContextFromDi(di) {
+        var _a;
+        return (_a = this.executionContextByDi.get(di)) !== null && _a !== void 0 ? _a : null;
+    }
+    createLineChain(di, line) {
+        let lineInstance;
+        try {
+            lineInstance = di.get({ token: line, optional: true });
+            // Пропускаем step. Так как нет действий
+            if (lineInstance === null) {
+                return Promise.resolve();
+            }
+        }
+        catch (e) {
+            // Логируем ошибку и дальше падаем
+            this.log.error(e);
+            return this.throwError(e, di);
+        }
+        if (!Array.isArray(lineInstance)) {
+            return this.instanceExecute(lineInstance, line, di);
+        }
+        return Promise.all(lineInstance.map((instance) => {
+            return this.instanceExecute(instance, line, di);
+        }));
+    }
+    instanceExecute(instance, line, di) {
+        if (!(instance instanceof Function)) {
+            const error = new TypeError(`Expected function in line processing "commandLineListTokens.${line.toString()}", received "${instance}".
+      Check that all commandLineListTokens subscribers return functions`);
+            if (process.env.NODE_ENV !== 'production') {
+                const instances = di.get(line);
+                const record = di.getRecord(line.toString());
+                // пробегаемся по всем инстансам и для текущего получаем его запись, из которой можно получить стек
+                for (let i = 0; i < instances.length; i++) {
+                    if (instances[i] === instance) {
+                        // @ts-expect-error
+                        error.stack = `${error.stack}\n---- caused by: ----\n${record.multi[i].stack || ''}`;
+                    }
+                }
+            }
+            this.log.error({
+                event: 'line-error',
+                error,
+                line: line.toString(),
+            });
+            return;
+        }
+        const { name = '' } = instance;
+        this.log.debug({
+            event: 'line-run',
+            line: line.toString(),
+            command: name,
+        });
+        return Promise.resolve()
+            .then(() => instance())
+            .catch((err) => {
+            var _a;
+            this.log[errors.isSilentError(err) ? 'debug' : 'error']({
+                event: 'line-error',
+                error: err,
+                line: line.toString(),
+                command: name,
+            });
+            // in case if any error happens during line execution results from other line handlers will not be used anyway
+            (_a = this.abortControllerByDi.get(di)) === null || _a === void 0 ? void 0 : _a.abort();
+            this.throwError(err, di);
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    throwError(err, di) {
+        if (typeof err === 'object') {
+            // eslint-disable-next-line no-param-reassign
+            err.di = di;
+        }
+        throw err;
+    }
+}
+
+exports.CommandLineRunner = CommandLineRunner;

package/lib/command/defaultLines.browser.js

@@ -0,0 +1,25 @@
+import { commandLineListTokens } from '@tramvai/core';
+
+const command = {
+    init: [commandLineListTokens.init, commandLineListTokens.listen],
+    close: [commandLineListTokens.close],
+    customer: [
+        commandLineListTokens.customerStart,
+        commandLineListTokens.resolveUserDeps,
+        commandLineListTokens.resolvePageDeps,
+        commandLineListTokens.generatePage,
+        commandLineListTokens.clear,
+    ],
+    spa: [
+        commandLineListTokens.resolveUserDeps,
+        commandLineListTokens.resolvePageDeps,
+        commandLineListTokens.spaTransition,
+    ],
+    afterSpa: [commandLineListTokens.afterSpaTransition],
+};
+const lines = {
+    server: command,
+    client: command,
+};
+
+export { lines };

package/lib/command/defaultLines.es.js

@@ -0,0 +1,25 @@
+import { commandLineListTokens } from '@tramvai/core';
+
+const command = {
+    init: [commandLineListTokens.init, commandLineListTokens.listen],
+    close: [commandLineListTokens.close],
+    customer: [
+        commandLineListTokens.customerStart,
+        commandLineListTokens.resolveUserDeps,
+        commandLineListTokens.resolvePageDeps,
+        commandLineListTokens.generatePage,
+        commandLineListTokens.clear,
+    ],
+    spa: [
+        commandLineListTokens.resolveUserDeps,
+        commandLineListTokens.resolvePageDeps,
+        commandLineListTokens.spaTransition,
+    ],
+    afterSpa: [commandLineListTokens.afterSpaTransition],
+};
+const lines = {
+    server: command,
+    client: command,
+};
+
+export { lines };