@tramvai/module-common 2.36.0 → 2.37.1

package/lib/actions/actionPageRunner.d.ts

@@ -1,6 +1,5 @@
-import type { Action, TramvaiAction } from '@tramvai/core';
-import type { LOGGER_TOKEN, ActionPageRunner as ActionPageRunnerInterface, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN } from '@tramvai/tokens-common';
-import type { ActionExecution } from './actionExecution';
+import type { Action, ExtractDependencyType, TramvaiAction } from '@tramvai/core';
+import type { LOGGER_TOKEN, ActionPageRunner as ActionPageRunnerInterface, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, ACTION_EXECUTION_TOKEN } from '@tramvai/tokens-common';
 declare module '@tramvai/tokens-common' {
     interface ExecutionContextValues {
         pageActions?: boolean;
@@ -10,12 +9,12 @@ export declare class ActionPageRunner implements ActionPageRunnerInterface {
     private deps;
     private log;
     constructor(deps: {
-        store: typeof STORE_TOKEN;
-        actionExecution: ActionExecution;
-        executionContextManager: typeof EXECUTION_CONTEXT_MANAGER_TOKEN;
-        commandLineExecutionContext: typeof COMMAND_LINE_EXECUTION_CONTEXT_TOKEN;
+        store: ExtractDependencyType<typeof STORE_TOKEN>;
+        actionExecution: ExtractDependencyType<typeof ACTION_EXECUTION_TOKEN>;
+        executionContextManager: ExtractDependencyType<typeof EXECUTION_CONTEXT_MANAGER_TOKEN>;
+        commandLineExecutionContext: ExtractDependencyType<typeof COMMAND_LINE_EXECUTION_CONTEXT_TOKEN>;
         limitTime: number;
-        logger: typeof LOGGER_TOKEN;
+        logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
     });
     runActions(actions: Array<Action | TramvaiAction<any[], any, any>>, stopRunAtError?: (error: Error) => boolean): Promise<void>;
     private syncStateActions;

package/lib/actions/actionRegistry.d.ts

@@ -8,6 +8,6 @@ export declare class ActionRegistry implements Interface {
     });
     add(type: string, actions: Action | Action[]): void;
     get(type: string, addingActions?: Action[]): Action[];
-    getGlobal(): Action[];
+    getGlobal(): Action[] | undefined;
     remove(type: string, actions?: Action | Action[]): void;
 }

package/lib/bundleManager/bundleManager.d.ts

@@ -1,22 +1,23 @@
-import type { BUNDLE_MANAGER_TOKEN, DISPATCHER_TOKEN, ActionsRegistry } from '@tramvai/tokens-common';
-import type { Bundle } from '@tramvai/core';
+import type { BUNDLE_MANAGER_TOKEN, DISPATCHER_TOKEN, ActionsRegistry, LOGGER_TOKEN } from '@tramvai/tokens-common';
+import type { Bundle, ExtractDependencyType } from '@tramvai/core';
 import type { ComponentRegistry } from '../componentRegistry/componentRegistry';
 declare type Interface = typeof BUNDLE_MANAGER_TOKEN;
-export declare class BundleManager implements Interface {
-    bundles: Record<string, () => Promise<{
+declare type Deps = {
+    bundleList: Record<string, () => Promise<{
         default: Bundle;
     }>>;
-    actionRegistry: ActionsRegistry;
     componentRegistry: ComponentRegistry;
-    dispatcher: typeof DISPATCHER_TOKEN;
-    constructor({ bundleList, componentRegistry, actionRegistry, dispatcher, logger }: {
-        bundleList: any;
-        componentRegistry: any;
-        actionRegistry: any;
-        dispatcher: any;
-        logger: any;
-    });
-    get(name: string, pageComponent: string): Promise<Bundle>;
+    actionRegistry: ActionsRegistry;
+    dispatcher: ExtractDependencyType<typeof DISPATCHER_TOKEN>;
+    logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
+};
+export declare class BundleManager implements Interface {
+    bundles: Deps['bundleList'];
+    actionRegistry: Deps['actionRegistry'];
+    componentRegistry: Deps['componentRegistry'];
+    dispatcher: Deps['dispatcher'];
+    constructor({ bundleList, componentRegistry, actionRegistry, dispatcher, logger }: Deps);
+    get(name: string, pageComponent: string): Promise<Bundle | undefined>;
     has(name: string, pageComponent: string): boolean;
     private resolve;
     private loadBundle;

package/lib/command/commandLineRunner.d.ts

@@ -1,23 +1,24 @@
 import type { CommandLineDescription, CommandLine, CommandLines } from '@tramvai/core';
 import type { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
-import type { Container, Provider } from '@tinkoff/dippy';
+import type { Container, ExtractDependencyType, Provider } from '@tinkoff/dippy';
 import type { ExecutionContext, EXECUTION_CONTEXT_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
-export declare class CommandLineRunner implements CommandLine {
+declare type Deps = {
     lines: CommandLines;
     rootDi: Container;
-    log: ReturnType<typeof LOGGER_TOKEN>;
-    metrics: typeof METRICS_MODULE_TOKEN;
-    executionContextManager: typeof EXECUTION_CONTEXT_MANAGER_TOKEN;
+    logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
+    metrics: ExtractDependencyType<typeof METRICS_MODULE_TOKEN> | null;
+    executionContextManager: ExtractDependencyType<typeof EXECUTION_CONTEXT_MANAGER_TOKEN>;
+};
+export declare class CommandLineRunner implements CommandLine {
+    lines: Deps['lines'];
+    rootDi: Deps['rootDi'];
+    log: ReturnType<Deps['logger']>;
+    metrics: Deps['metrics'];
+    executionContextManager: Deps['executionContextManager'];
     private metricsInstance;
     private executionContextByDi;
     private abortControllerByDi;
-    constructor({ lines, rootDi, logger, metrics, executionContextManager, }: {
-        lines: CommandLines;
-        rootDi: Container;
-        logger: typeof LOGGER_TOKEN;
-        metrics?: typeof METRICS_MODULE_TOKEN;
-        executionContextManager: typeof EXECUTION_CONTEXT_MANAGER_TOKEN;
-    });
+    constructor({ lines, rootDi, logger, metrics, executionContextManager }: Deps);
     run(type: keyof CommandLines, status: keyof CommandLineDescription, providers?: Provider[], customDi?: Container): Promise<Container>;
     resolveExecutionContextFromDi(di: Container): ExecutionContext | null;
     private createLineChain;
@@ -25,3 +26,4 @@ export declare class CommandLineRunner implements CommandLine {
     private createDurationMetric;
     private throwError;
 }
+export {};

package/lib/createConsumerContext/createConsumerContext.d.ts

@@ -1,16 +1,22 @@
-import type { Container } from '@tinkoff/dippy';
+import type { Container, ExtractDependencyType } from '@tinkoff/dippy';
 import type { Event, Reducer } from '@tramvai/state';
 import type { Action, TramvaiAction } from '@tramvai/core';
-import type { PUBSUB_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import type { STORE_TOKEN, PUBSUB_TOKEN, CONTEXT_TOKEN, DISPATCHER_CONTEXT_TOKEN } from '@tramvai/tokens-common';
 import type { PlatformAction } from './typings';
 declare type ContextType = typeof CONTEXT_TOKEN;
-export declare class ConsumerContext implements ContextType {
+declare type Deps = {
     di: Container;
-    pubsub: typeof PUBSUB_TOKEN;
+    dispatcherContext: ExtractDependencyType<typeof DISPATCHER_CONTEXT_TOKEN>;
+    pubsub: ExtractDependencyType<typeof PUBSUB_TOKEN>;
+    store: ExtractDependencyType<typeof STORE_TOKEN>;
+};
+export declare class ConsumerContext implements ContextType {
+    di: Deps['di'];
+    pubsub: Deps['pubsub'];
     private dispatcher;
     private store;
     executeAction: (action: PlatformAction<any, any> | Action<any, any, any> | TramvaiAction<any[], any, any>, payload?: any) => Promise<any>;
-    dispatch: <Payload>(actionOrNameEvent: string | Event<Payload>, payload?: Payload) => Promise<Payload>;
+    dispatch: <Payload>(actionOrNameEvent: string | Event<Payload>, payload?: Payload | undefined) => Promise<Payload>;
     dispatchWith: (createActionOrType: (...args: unknown[]) => Event | Event, options?: any) => (...args: unknown[]) => Promise<any>;
     /**
      * @deprecated
@@ -26,17 +32,7 @@ export declare class ConsumerContext implements ContextType {
     hasStore: (store: Reducer<any>) => boolean;
     registerStore: (store: Reducer<any>) => void;
     unregisterStore: (store: Reducer<any>) => void;
-    constructor({ di, dispatcherContext, pubsub, store }: {
-        di: any;
-        dispatcherContext: any;
-        pubsub: any;
-        store: any;
-    });
+    constructor({ di, dispatcherContext, pubsub, store }: Deps);
 }
-export declare function createConsumerContext({ di, dispatcherContext, pubsub, store }: {
-    di: any;
-    dispatcherContext: any;
-    pubsub: any;
-    store: any;
-}): ContextType;
+export declare function createConsumerContext({ di, dispatcherContext, pubsub, store }: Deps): ContextType;
 export {};

package/lib/index.browser.js

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
 import eachObj from '@tinkoff/utils/object/each';
-import { createBundle, Scope, Module, provide, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN, isTramvaiAction, ACTION_PARAMETERS, ACTIONS_LIST_TOKEN, IS_DI_CHILD_CONTAINER_TOKEN, BUNDLE_LIST_TOKEN } from '@tramvai/core';
+import { createBundle, provide, Scope, Module, commandLineListTokens, COMMAND_LINE_RUNNER_TOKEN, COMMAND_LINES_TOKEN, DI_TOKEN, isTramvaiAction, ACTION_PARAMETERS, createToken, ACTIONS_LIST_TOKEN, IS_DI_CHILD_CONTAINER_TOKEN, BUNDLE_LIST_TOKEN } from '@tramvai/core';
 import { EnvironmentModule } from '@tramvai/module-environment';
 import { CookieModule } from '@tramvai/module-cookie';
 export { COOKIE_MANAGER_TOKEN } from '@tramvai/module-cookie';
@@ -8,6 +8,8 @@ import { LogModule } from '@tramvai/module-log';
 import { Hooks } from '@tinkoff/hook-runner';
 import { REQUEST_MANAGER_TOKEN, COMBINE_REDUCERS, STORE_TOKEN, RESPONSE_MANAGER_TOKEN, ACTION_EXECUTION_TOKEN, ROOT_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, PUBSUB_FACTORY_TOKEN, PUBSUB_TOKEN, ROOT_PUBSUB_TOKEN, INITIAL_APP_STATE_TOKEN, ACTION_REGISTRY_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, ACTION_PAGE_RUNNER_TOKEN, DISPATCHER_TOKEN, DISPATCHER_CONTEXT_TOKEN, STORE_MIDDLEWARE, CREATE_CACHE_TOKEN, CLEAR_CACHE_TOKEN, REGISTER_CLEAR_CACHE_TOKEN, HOOK_TOKEN, COMPONENT_REGISTRY_TOKEN, BUNDLE_MANAGER_TOKEN, ADDITIONAL_BUNDLE_TOKEN } from '@tramvai/tokens-common';
 export * from '@tramvai/tokens-common';
+import isObject from '@tinkoff/utils/is/object';
+import isArray from '@tinkoff/utils/is/array';
 import { resolveLazyComponent, __lazyErrorHandler } from '@tramvai/react';
 import { fileSystemPagesEnabled, getAllFileSystemPages, isFileSystemPageComponent } from '@tramvai/experiments';
 import pathOr from '@tinkoff/utils/object/pathOr';
@@ -18,7 +20,7 @@ import { format, parse } from '@tinkoff/url';
 import isEmpty from '@tinkoff/utils/is/empty';
 import values from '@tinkoff/utils/object/values';
 import { METRICS_MODULE_TOKEN } from '@tramvai/tokens-metrics';
-import { createChildContainer, provide as provide$1, Scope as Scope$1, createToken } from '@tinkoff/dippy';
+import { createChildContainer, provide as provide$1, Scope as Scope$1, createToken as createToken$1 } from '@tinkoff/dippy';
 import noop from '@tinkoff/utils/function/noop';
 import { isSilentError, ConditionFailError, ExecutionAbortError } from '@tinkoff/errors';
 import { PubSub } from '@tinkoff/pubsub';
@@ -77,16 +79,19 @@ class BundleManager {
         if (pageComponent && bundle.components[pageComponent]) {
             const componentOrLoader = bundle.components[pageComponent];
             const component = await resolveLazyComponent(componentOrLoader);
+            if (!component) {
+                return;
+            }
             // allow page components to register any other components
-            if ('components' in component) {
+            if ('components' in component && isObject(component.components)) {
                 eachObj((cmp, name) => {
                     this.componentRegistry.add(name, cmp, pageComponent);
                 }, component.components);
             }
-            if ('actions' in component) {
+            if ('actions' in component && isArray(component.actions)) {
                 this.actionRegistry.add(pageComponent, component.actions);
             }
-            if ('reducers' in component) {
+            if ('reducers' in component && isArray(component.reducers)) {
                 component.reducers.forEach((reducer) => {
                     this.dispatcher.registerStore(reducer);
                 });
@@ -194,19 +199,19 @@ class RequestManager {
 }
 
 const sharedProviders$1 = [
-    {
+    provide({
         provide: REQUEST_MANAGER_TOKEN,
         scope: Scope.REQUEST,
         useClass: RequestManager,
         deps: {
             request: FASTIFY_REQUEST,
         },
-    },
-    {
+    }),
+    provide({
         provide: COMBINE_REDUCERS,
         multi: true,
         useValue: RequestManagerStore,
-    },
+    }),
 ];
 
 let RequestManagerModule = class RequestManagerModule {
@@ -288,11 +293,11 @@ class ResponseManager {
 }
 
 const sharedProviders = [
-    {
+    provide({
         provide: RESPONSE_MANAGER_TOKEN,
         scope: Scope.REQUEST,
         useClass: ResponseManager,
-    },
+    }),
 ];
 
 let ResponseManagerModule = class ResponseManagerModule {
@@ -301,10 +306,11 @@ ResponseManagerModule = __decorate([
     Module({
         providers: [
             ...sharedProviders,
-            {
+            provide({
                 provide: FASTIFY_RESPONSE,
+                // @ts-expect-error
                 useValue: {},
-            },
+            }),
         ],
     })
 ], ResponseManagerModule);
@@ -340,8 +346,8 @@ class ConsumerContext {
         this.dehydrate = () => ({
             dispatcher: this.dispatcher.dehydrate(),
         });
-        this.getState = (reducer) => {
-            return this.store.getState(reducer);
+        this.getState = (...args) => {
+            return this.store.getState(args[0]);
         };
         this.subscribe = (...args) => {
             return this.store.subscribe(args[0], args[1]);
@@ -350,6 +356,7 @@ class ConsumerContext {
         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);
@@ -380,7 +387,7 @@ const resolveDi = (type, status, diContainer, providers) => {
     return di;
 };
 class CommandLineRunner {
-    constructor({ lines, rootDi, logger, metrics, executionContextManager, }) {
+    constructor({ lines, rootDi, logger, metrics, executionContextManager }) {
         this.executionContextByDi = new WeakMap();
         this.abortControllerByDi = new WeakMap();
         this.lines = lines;
@@ -455,6 +462,7 @@ class CommandLineRunner {
                 // пробегаемся по всем инстансам и для текущего получаем его запись, из которой можно получить стек
                 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 || ''}`;
                     }
                 }
@@ -555,7 +563,7 @@ CommandModule = __decorate([
             }),
             provide$1({
                 provide: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
-                useFactory: ({ di, commandLineRunner, }) => {
+                useFactory: ({ di, commandLineRunner }) => {
                     return () => {
                         return commandLineRunner.resolveExecutionContextFromDi(di);
                     };
@@ -580,7 +588,7 @@ let PubSubModule = class PubSubModule {
 PubSubModule = __decorate([
     Module({
         providers: [
-            {
+            provide({
                 // Фабрика для создания pubsub
                 provide: PUBSUB_FACTORY_TOKEN,
                 scope: Scope.SINGLETON,
@@ -592,34 +600,35 @@ PubSubModule = __decorate([
                 deps: {
                     logger: LOGGER_TOKEN,
                 },
-            },
-            {
+            }),
+            provide({
                 provide: PUBSUB_TOKEN,
                 scope: Scope.REQUEST,
                 useFactory: ({ createPubsub }) => createPubsub(),
                 deps: {
                     createPubsub: PUBSUB_FACTORY_TOKEN,
                 },
-            },
-            {
+            }),
+            provide({
                 provide: ROOT_PUBSUB_TOKEN,
                 scope: Scope.SINGLETON,
                 useFactory: ({ createPubsub }) => createPubsub(),
                 deps: {
                     createPubsub: PUBSUB_FACTORY_TOKEN,
                 },
-            },
+            }),
         ],
     })
 ], PubSubModule);
 
 const providers$2 = [
-    {
+    provide({
         provide: INITIAL_APP_STATE_TOKEN,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         useFactory: () => JSON.parse(document.getElementById('__TRAMVAI_STATE__').textContent),
         scope: Scope.REQUEST,
-    },
-    {
+    }),
+    provide({
         provide: commandLineListTokens.listen,
         useFactory: ({ commandLineRunner, }) => {
             return function initClientCommand() {
@@ -628,7 +637,7 @@ const providers$2 = [
         },
         deps: { commandLineRunner: COMMAND_LINE_RUNNER_TOKEN },
         multi: true,
-    },
+    }),
 ];
 
 const actionServerStateEvent = createEvent('action state execution in server');
@@ -896,23 +905,24 @@ const pageBrowser = {
     },
 };
 
+const LIMIT_ACTION_GLOBAL_TIME_RUN = createToken('limitActionGlobalTimeRun');
 let ActionModule = class ActionModule {
 };
 ActionModule = __decorate([
     Module({
         providers: [
-            {
+            provide({
                 provide: COMBINE_REDUCERS,
                 multi: true,
                 useValue: actionTramvaiReducer,
-            },
-            {
+            }),
+            provide({
                 // Регистер глобальных экшенов
                 provide: ACTION_REGISTRY_TOKEN,
                 scope: Scope.SINGLETON,
                 useClass: ActionRegistry,
                 deps: { actionsList: ACTIONS_LIST_TOKEN },
-            },
+            }),
             provide({
                 provide: ACTION_EXECUTION_TOKEN,
                 scope: Scope.REQUEST,
@@ -938,19 +948,19 @@ ActionModule = __decorate([
                     executionContextManager: EXECUTION_CONTEXT_MANAGER_TOKEN,
                     commandLineExecutionContext: COMMAND_LINE_EXECUTION_CONTEXT_TOKEN,
                     store: STORE_TOKEN,
-                    limitTime: 'limitActionGlobalTimeRun',
+                    limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
                     logger: LOGGER_TOKEN,
                 },
             }),
-            {
-                provide: 'limitActionGlobalTimeRun',
+            provide({
+                provide: LIMIT_ACTION_GLOBAL_TIME_RUN,
                 useValue: 500,
-            },
-            {
+            }),
+            provide({
                 provide: ACTION_CONDITIONALS,
                 multi: true,
                 useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
-            },
+            }),
         ],
     })
 ], ActionModule);
@@ -960,7 +970,7 @@ let StateModule = class StateModule {
 StateModule = __decorate([
     Module({
         providers: [
-            {
+            provide({
                 provide: DISPATCHER_TOKEN,
                 scope: Scope.SINGLETON,
                 useFactory: ({ stores }) => createDispatcher({ stores: stores && flatten(stores) }),
@@ -970,8 +980,8 @@ StateModule = __decorate([
                         optional: true,
                     },
                 },
-            },
-            {
+            }),
+            provide({
                 provide: DISPATCHER_CONTEXT_TOKEN,
                 scope: Scope.REQUEST,
                 useFactory: ({ dispatcher, initialState, middlewares }) => {
@@ -985,19 +995,19 @@ StateModule = __decorate([
                     middlewares: { token: STORE_MIDDLEWARE, optional: true },
                     initialState: { token: INITIAL_APP_STATE_TOKEN, optional: true },
                 },
-            },
-            {
+            }),
+            provide({
                 provide: STORE_TOKEN,
                 scope: Scope.REQUEST,
                 useFactory: ({ dispatcherContext }) => ({
-                    getState: (reducer) => dispatcherContext.getState(reducer),
-                    dispatch: (action) => dispatcherContext.dispatch(action),
-                    subscribe: (reducer, callback) => dispatcherContext.subscribe(reducer, callback),
+                    getState: dispatcherContext.getState.bind(dispatcherContext),
+                    dispatch: dispatcherContext.dispatch.bind(dispatcherContext),
+                    subscribe: dispatcherContext.subscribe.bind(dispatcherContext),
                 }),
                 deps: {
                     dispatcherContext: DISPATCHER_CONTEXT_TOKEN,
                 },
-            },
+            }),
         ],
     })
 ], StateModule);
@@ -1008,7 +1018,7 @@ const cacheFactory = (type, options = { max: 100 }) => {
 
 const providers$1 = [];
 
-const cachesToken = createToken('_cachesList');
+const cachesToken = createToken$1('_cachesList');
 let CacheModule = class CacheModule {
 };
 CacheModule = __decorate([
@@ -1103,7 +1113,8 @@ class ExecutionContextManager {
             throw error;
         }
         finally {
-            if (abortListener) {
+            // @ts-expect-error
+            if (abortListener && parentContext) {
                 parentContext.abortSignal.removeEventListener('abort', abortListener);
             }
         }
@@ -1246,11 +1257,11 @@ const actionsProviders = [
         multi: true,
         useValue: [ACTION_EXECUTION_TOKEN, ACTION_PAGE_RUNNER_TOKEN],
     }),
-    {
+    provide({
         provide: COMBINE_REDUCERS,
         multi: true,
         useValue: actionTramvaiReducer,
-    },
+    }),
 ];
 
 let CommonChildAppModule = class CommonChildAppModule {