@tramvai/module-common 2.145.1 → 2.146.1

package/lib/actions/ActionModule.browser.js

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
 import { createToken, Module, provide, Scope, ACTIONS_LIST_TOKEN, DI_TOKEN, optional } from '@tramvai/core';
-import { COMBINE_REDUCERS, ACTION_REGISTRY_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, ACTION_PAGE_RUNNER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import { COMBINE_REDUCERS, ACTION_REGISTRY_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN, ACTION_PAGE_RUNNER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { SERVER_RESPONSE_TASK_MANAGER, SERVER_RESPONSE_STREAM } from '@tramvai/tokens-server-private';
 import { actionTramvaiReducer } from './actionTramvaiReducer.browser.js';
 import { ActionExecution } from './actionExecution.browser.js';
@@ -16,6 +16,8 @@ import { pageServer } from './conditions/pageServer.browser.js';
 export { pageServer } from './conditions/pageServer.browser.js';
 import { pageBrowser } from './conditions/pageBrowser.browser.js';
 export { pageBrowser } from './conditions/pageBrowser.browser.js';
+import { dynamicCondition } from './conditions/dynamic.browser.js';
+export { dynamicCondition } from './conditions/dynamic.browser.js';
 import { providers } from './deferred/providers.browser.browser.js';
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = createToken('limitActionGlobalTimeRun');
@@ -50,6 +52,7 @@ ActionModule = __decorate([
                         token: 'actionTransformAction',
                         optional: true,
                     },
+                    deferredActionsMap: DEFERRED_ACTIONS_MAP_TOKEN,
                 },
             }),
             provide({
@@ -75,7 +78,14 @@ ActionModule = __decorate([
             provide({
                 provide: ACTION_CONDITIONALS,
                 multi: true,
-                useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
+                useValue: [
+                    alwaysCondition,
+                    onlyServer,
+                    onlyBrowser,
+                    pageServer,
+                    pageBrowser,
+                    dynamicCondition,
+                ],
             }),
             ...providers,
         ],

package/lib/actions/ActionModule.d.ts

@@ -3,7 +3,8 @@ import { onlyServer } from './conditions/onlyServer';
 import { onlyBrowser } from './conditions/onlyBrowser';
 import { pageServer } from './conditions/pageServer';
 import { pageBrowser } from './conditions/pageBrowser';
-export { alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser };
+import { dynamicCondition } from './conditions/dynamic';
+export { alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser, dynamicCondition };
 declare class ActionModule {
 }
 export { ActionModule };

package/lib/actions/ActionModule.es.js

@@ -1,6 +1,6 @@
 import { __decorate } from 'tslib';
 import { createToken, Module, provide, Scope, ACTIONS_LIST_TOKEN, DI_TOKEN, optional } from '@tramvai/core';
-import { COMBINE_REDUCERS, ACTION_REGISTRY_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, ACTION_PAGE_RUNNER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import { COMBINE_REDUCERS, ACTION_REGISTRY_TOKEN, ACTION_EXECUTION_TOKEN, ACTION_CONDITIONALS, CONTEXT_TOKEN, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN, ACTION_PAGE_RUNNER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
 import { SERVER_RESPONSE_TASK_MANAGER, SERVER_RESPONSE_STREAM } from '@tramvai/tokens-server-private';
 import { actionTramvaiReducer } from './actionTramvaiReducer.es.js';
 import { ActionExecution } from './actionExecution.es.js';
@@ -16,6 +16,8 @@ import { pageServer } from './conditions/pageServer.es.js';
 export { pageServer } from './conditions/pageServer.es.js';
 import { pageBrowser } from './conditions/pageBrowser.es.js';
 export { pageBrowser } from './conditions/pageBrowser.es.js';
+import { dynamicCondition } from './conditions/dynamic.es.js';
+export { dynamicCondition } from './conditions/dynamic.es.js';
 import { providers } from './deferred/providers.es.js';
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = createToken('limitActionGlobalTimeRun');
@@ -50,6 +52,7 @@ ActionModule = __decorate([
                         token: 'actionTransformAction',
                         optional: true,
                     },
+                    deferredActionsMap: DEFERRED_ACTIONS_MAP_TOKEN,
                 },
             }),
             provide({
@@ -75,7 +78,14 @@ ActionModule = __decorate([
             provide({
                 provide: ACTION_CONDITIONALS,
                 multi: true,
-                useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
+                useValue: [
+                    alwaysCondition,
+                    onlyServer,
+                    onlyBrowser,
+                    pageServer,
+                    pageBrowser,
+                    dynamicCondition,
+                ],
             }),
             ...providers,
         ],

package/lib/actions/ActionModule.js

@@ -15,6 +15,7 @@ var onlyServer = require('./conditions/onlyServer.js');
 var onlyBrowser = require('./conditions/onlyBrowser.js');
 var pageServer = require('./conditions/pageServer.js');
 var pageBrowser = require('./conditions/pageBrowser.js');
+var dynamic = require('./conditions/dynamic.js');
 var providers = require('./deferred/providers.js');
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = core.createToken('limitActionGlobalTimeRun');
@@ -49,6 +50,7 @@ exports.ActionModule = tslib.__decorate([
                         token: 'actionTransformAction',
                         optional: true,
                     },
+                    deferredActionsMap: tokensCommon.DEFERRED_ACTIONS_MAP_TOKEN,
                 },
             }),
             core.provide({
@@ -74,7 +76,14 @@ exports.ActionModule = tslib.__decorate([
             core.provide({
                 provide: tokensCommon.ACTION_CONDITIONALS,
                 multi: true,
-                useValue: [always.alwaysCondition, onlyServer.onlyServer, onlyBrowser.onlyBrowser, pageServer.pageServer, pageBrowser.pageBrowser],
+                useValue: [
+                    always.alwaysCondition,
+                    onlyServer.onlyServer,
+                    onlyBrowser.onlyBrowser,
+                    pageServer.pageServer,
+                    pageBrowser.pageBrowser,
+                    dynamic.dynamicCondition,
+                ],
             }),
             ...providers.providers,
         ],
@@ -86,3 +95,4 @@ exports.onlyServer = onlyServer.onlyServer;
 exports.onlyBrowser = onlyBrowser.onlyBrowser;
 exports.pageServer = pageServer.pageServer;
 exports.pageBrowser = pageBrowser.pageBrowser;
+exports.dynamicCondition = dynamic.dynamicCondition;

package/lib/actions/actionExecution.browser.js

@@ -1,19 +1,22 @@
 import flatten from '@tinkoff/utils/array/flatten';
 import identity from '@tinkoff/utils/function/identity';
+import isPromise from '@tinkoff/utils/is/promise';
 import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
 import objectMap from '@tinkoff/utils/object/map';
 import { ConditionFailError } from '@tinkoff/errors';
 import { ActionChecker } from './actionChecker.browser.js';
 import { actionType } from './constants.browser.js';
 import { actionTramvaiReducer } from './actionTramvaiReducer.browser.js';
+import { Deferred } from './deferred/deferred.browser.js';
 
 const EMPTY_DEPS = {};
 const getParameters = (action) => action[ACTION_PARAMETERS];
 class ActionExecution {
-    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+    constructor({ store, context, deferredActionsMap, di, executionContextManager, actionConditionals, transformAction, }) {
         this.actionConditionals = flatten(actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
         this.context = context;
         this.store = store;
+        this.deferredActionsMap = deferredActionsMap;
         this.di = di;
         this.executionContextManager = executionContextManager;
         this.execution = new Map();
@@ -27,18 +30,10 @@ class ActionExecution {
     }
     async runInContext(executionContext, action, ...params) {
         var _a;
-        let parameters;
         const payload = params[0];
         // TODO: replace type with pure context usage
         const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? actionType.global : actionType.local;
-        // TODO: remove else branch after migration to new declareAction
-        if (isTramvaiAction(action)) {
-            parameters = action;
-        }
-        else {
-            this.transformAction(action);
-            parameters = getParameters(action);
-        }
+        const parameters = this.getActionParameters(action);
         if (!parameters) {
             throw new Error('Cannot resolve internal data for action. Make sure you are using the result of `declareAction` call as an action');
         }
@@ -54,6 +49,14 @@ class ActionExecution {
                     return Promise.resolve();
             }
         }
+        const isDeferredAction = parameters.deferred;
+        // will be created when spa run actions mode is "before"
+        if (isDeferredAction && !this.deferredActionsMap.get(action.name)) {
+            const deferred = new Deferred();
+            // avoid unhandled promise rejection
+            deferred.promise.catch(() => { });
+            this.deferredActionsMap.set(action.name, deferred);
+        }
         executionState.status = 'pending';
         return this.executionContextManager.withContext(executionContext, {
             name: parameters.name,
@@ -63,7 +66,20 @@ class ActionExecution {
             return Promise.resolve()
                 .then(() => {
                 if (isTramvaiAction(action)) {
-                    return action.fn.apply(context, params);
+                    const result = action.fn.apply(context, params);
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const deferred = this.deferredActionsMap.get(action.name);
+                    if (isDeferredAction) {
+                        if (!deferred.isResolved() && !deferred.isRejected() && isPromise(result)) {
+                            // eslint-disable-next-line promise/no-nesting
+                            result.then(deferred.resolve).catch(deferred.reject);
+                        }
+                        // pass success state for deferred actions to the client
+                        // it will be helpful to detect deferred executions for SPA-transitions only
+                        // eslint-disable-next-line promise/no-return-wrap
+                        return Promise.resolve();
+                    }
+                    return result;
                 }
                 return action(this.context, payload, context.deps);
             })
@@ -80,9 +96,26 @@ class ActionExecution {
     async run(action, ...params) {
         return this.runInContext(null, action, ...params);
     }
+    canExecute(action) {
+        const parameters = this.getActionParameters(action);
+        const executionState = this.getExecutionState(parameters.name);
+        // @todo any cases when hadcoded global action type and payload could cause problems?
+        return this.canExecuteAction(undefined, parameters, executionState, actionType.global);
+    }
+    getActionParameters(action) {
+        let parameters;
+        // TODO: remove else branch after migration to new declareAction
+        if (isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        return parameters;
+    }
     getExecutionState(name) {
         let executionState = this.execution.get(name);
-        // TODO: probably do not need to create executionState on client as it is not used
         if (!executionState) {
             executionState = { status: 'pending', state: {} };
             this.execution.set(name, executionState);

package/lib/actions/actionExecution.d.ts

@@ -1,5 +1,5 @@
 import type { Action, ActionParameters, DI_TOKEN } from '@tramvai/core';
-import type { CONTEXT_TOKEN, ActionCondition, STORE_TOKEN, ActionExecution as Interface, EXECUTION_CONTEXT_MANAGER_TOKEN, ExecutionContext } from '@tramvai/tokens-common';
+import type { CONTEXT_TOKEN, ActionCondition, STORE_TOKEN, ActionExecution as Interface, EXECUTION_CONTEXT_MANAGER_TOKEN, ExecutionContext, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
 import type { TramvaiAction } from '@tramvai/types-actions-state-context';
 import type { ExtractDependencyType } from '@tinkoff/dippy';
 export declare const getParameters: (action: Action) => ActionParameters<any, any>;
@@ -14,20 +14,24 @@ export declare class ActionExecution implements Interface {
     execution: Map<string, ExecutionState>;
     private actionConditionals;
     private context;
+    private deferredActionsMap;
     private store;
     private executionContextManager;
     private di;
     private transformAction;
-    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }: {
+    constructor({ store, context, deferredActionsMap, di, executionContextManager, actionConditionals, transformAction, }: {
         actionConditionals: (ActionCondition | ActionCondition[])[] | null;
         store: ExtractDependencyType<typeof STORE_TOKEN>;
         context: ExtractDependencyType<typeof CONTEXT_TOKEN>;
+        deferredActionsMap: ExtractDependencyType<typeof DEFERRED_ACTIONS_MAP_TOKEN>;
         di: ExtractDependencyType<typeof DI_TOKEN>;
         executionContextManager: ExtractDependencyType<typeof EXECUTION_CONTEXT_MANAGER_TOKEN>;
         transformAction?: TransformAction;
     });
     runInContext(executionContext: ExecutionContext | null, action: Action | TramvaiAction<any, any, any>, ...params: any[]): Promise<any>;
     run(action: Action | TramvaiAction<any, any, any>, ...params: any[]): Promise<any>;
+    canExecute(action: Action | TramvaiAction<any, any, any>): boolean;
+    private getActionParameters;
     private getExecutionState;
     private canExecuteAction;
     private createActionContext;

package/lib/actions/actionExecution.es.js

@@ -1,19 +1,22 @@
 import flatten from '@tinkoff/utils/array/flatten';
 import identity from '@tinkoff/utils/function/identity';
+import isPromise from '@tinkoff/utils/is/promise';
 import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
 import objectMap from '@tinkoff/utils/object/map';
 import { ConditionFailError } from '@tinkoff/errors';
 import { ActionChecker } from './actionChecker.es.js';
 import { actionType } from './constants.es.js';
 import { actionTramvaiReducer } from './actionTramvaiReducer.es.js';
+import { Deferred } from './deferred/deferred.es.js';
 
 const EMPTY_DEPS = {};
 const getParameters = (action) => action[ACTION_PARAMETERS];
 class ActionExecution {
-    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+    constructor({ store, context, deferredActionsMap, di, executionContextManager, actionConditionals, transformAction, }) {
         this.actionConditionals = flatten(actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
         this.context = context;
         this.store = store;
+        this.deferredActionsMap = deferredActionsMap;
         this.di = di;
         this.executionContextManager = executionContextManager;
         this.execution = new Map();
@@ -27,18 +30,10 @@ class ActionExecution {
     }
     async runInContext(executionContext, action, ...params) {
         var _a;
-        let parameters;
         const payload = params[0];
         // TODO: replace type with pure context usage
         const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? actionType.global : actionType.local;
-        // TODO: remove else branch after migration to new declareAction
-        if (isTramvaiAction(action)) {
-            parameters = action;
-        }
-        else {
-            this.transformAction(action);
-            parameters = getParameters(action);
-        }
+        const parameters = this.getActionParameters(action);
         if (!parameters) {
             throw new Error('Cannot resolve internal data for action. Make sure you are using the result of `declareAction` call as an action');
         }
@@ -54,6 +49,14 @@ class ActionExecution {
                     return Promise.resolve();
             }
         }
+        const isDeferredAction = parameters.deferred;
+        // will be created when spa run actions mode is "before"
+        if (isDeferredAction && !this.deferredActionsMap.get(action.name)) {
+            const deferred = new Deferred();
+            // avoid unhandled promise rejection
+            deferred.promise.catch(() => { });
+            this.deferredActionsMap.set(action.name, deferred);
+        }
         executionState.status = 'pending';
         return this.executionContextManager.withContext(executionContext, {
             name: parameters.name,
@@ -63,7 +66,20 @@ class ActionExecution {
             return Promise.resolve()
                 .then(() => {
                 if (isTramvaiAction(action)) {
-                    return action.fn.apply(context, params);
+                    const result = action.fn.apply(context, params);
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const deferred = this.deferredActionsMap.get(action.name);
+                    if (isDeferredAction) {
+                        if (!deferred.isResolved() && !deferred.isRejected() && isPromise(result)) {
+                            // eslint-disable-next-line promise/no-nesting
+                            result.then(deferred.resolve).catch(deferred.reject);
+                        }
+                        // pass success state for deferred actions to the client
+                        // it will be helpful to detect deferred executions for SPA-transitions only
+                        // eslint-disable-next-line promise/no-return-wrap
+                        return Promise.resolve();
+                    }
+                    return result;
                 }
                 return action(this.context, payload, context.deps);
             })
@@ -80,9 +96,26 @@ class ActionExecution {
     async run(action, ...params) {
         return this.runInContext(null, action, ...params);
     }
+    canExecute(action) {
+        const parameters = this.getActionParameters(action);
+        const executionState = this.getExecutionState(parameters.name);
+        // @todo any cases when hadcoded global action type and payload could cause problems?
+        return this.canExecuteAction(undefined, parameters, executionState, actionType.global);
+    }
+    getActionParameters(action) {
+        let parameters;
+        // TODO: remove else branch after migration to new declareAction
+        if (isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        return parameters;
+    }
     getExecutionState(name) {
         let executionState = this.execution.get(name);
-        // TODO: probably do not need to create executionState on client as it is not used
         if (!executionState) {
             executionState = { status: 'pending', state: {} };
             this.execution.set(name, executionState);

package/lib/actions/actionExecution.js

@@ -4,26 +4,30 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var flatten = require('@tinkoff/utils/array/flatten');
 var identity = require('@tinkoff/utils/function/identity');
+var isPromise = require('@tinkoff/utils/is/promise');
 var core = require('@tramvai/core');
 var objectMap = require('@tinkoff/utils/object/map');
 var errors = require('@tinkoff/errors');
 var actionChecker = require('./actionChecker.js');
 var constants = require('./constants.js');
 var actionTramvaiReducer = require('./actionTramvaiReducer.js');
+var deferred = require('./deferred/deferred.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
 var identity__default = /*#__PURE__*/_interopDefaultLegacy(identity);
+var isPromise__default = /*#__PURE__*/_interopDefaultLegacy(isPromise);
 var objectMap__default = /*#__PURE__*/_interopDefaultLegacy(objectMap);
 
 const EMPTY_DEPS = {};
 const getParameters = (action) => action[core.ACTION_PARAMETERS];
 class ActionExecution {
-    constructor({ store, context, di, executionContextManager, actionConditionals, transformAction, }) {
+    constructor({ store, context, deferredActionsMap, di, executionContextManager, actionConditionals, transformAction, }) {
         this.actionConditionals = flatten__default["default"](actionConditionals !== null && actionConditionals !== void 0 ? actionConditionals : []);
         this.context = context;
         this.store = store;
+        this.deferredActionsMap = deferredActionsMap;
         this.di = di;
         this.executionContextManager = executionContextManager;
         this.execution = new Map();
@@ -37,18 +41,10 @@ class ActionExecution {
     }
     async runInContext(executionContext, action, ...params) {
         var _a;
-        let parameters;
         const payload = params[0];
         // TODO: replace type with pure context usage
         const type = (executionContext === null || executionContext === void 0 ? void 0 : executionContext.values.pageActions) === true ? constants.actionType.global : constants.actionType.local;
-        // TODO: remove else branch after migration to new declareAction
-        if (core.isTramvaiAction(action)) {
-            parameters = action;
-        }
-        else {
-            this.transformAction(action);
-            parameters = getParameters(action);
-        }
+        const parameters = this.getActionParameters(action);
         if (!parameters) {
             throw new Error('Cannot resolve internal data for action. Make sure you are using the result of `declareAction` call as an action');
         }
@@ -64,6 +60,14 @@ class ActionExecution {
                     return Promise.resolve();
             }
         }
+        const isDeferredAction = parameters.deferred;
+        // will be created when spa run actions mode is "before"
+        if (isDeferredAction && !this.deferredActionsMap.get(action.name)) {
+            const deferred$1 = new deferred.Deferred();
+            // avoid unhandled promise rejection
+            deferred$1.promise.catch(() => { });
+            this.deferredActionsMap.set(action.name, deferred$1);
+        }
         executionState.status = 'pending';
         return this.executionContextManager.withContext(executionContext, {
             name: parameters.name,
@@ -73,7 +77,20 @@ class ActionExecution {
             return Promise.resolve()
                 .then(() => {
                 if (core.isTramvaiAction(action)) {
-                    return action.fn.apply(context, params);
+                    const result = action.fn.apply(context, params);
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    const deferred = this.deferredActionsMap.get(action.name);
+                    if (isDeferredAction) {
+                        if (!deferred.isResolved() && !deferred.isRejected() && isPromise__default["default"](result)) {
+                            // eslint-disable-next-line promise/no-nesting
+                            result.then(deferred.resolve).catch(deferred.reject);
+                        }
+                        // pass success state for deferred actions to the client
+                        // it will be helpful to detect deferred executions for SPA-transitions only
+                        // eslint-disable-next-line promise/no-return-wrap
+                        return Promise.resolve();
+                    }
+                    return result;
                 }
                 return action(this.context, payload, context.deps);
             })
@@ -90,9 +107,26 @@ class ActionExecution {
     async run(action, ...params) {
         return this.runInContext(null, action, ...params);
     }
+    canExecute(action) {
+        const parameters = this.getActionParameters(action);
+        const executionState = this.getExecutionState(parameters.name);
+        // @todo any cases when hadcoded global action type and payload could cause problems?
+        return this.canExecuteAction(undefined, parameters, executionState, constants.actionType.global);
+    }
+    getActionParameters(action) {
+        let parameters;
+        // TODO: remove else branch after migration to new declareAction
+        if (core.isTramvaiAction(action)) {
+            parameters = action;
+        }
+        else {
+            this.transformAction(action);
+            parameters = getParameters(action);
+        }
+        return parameters;
+    }
     getExecutionState(name) {
         let executionState = this.execution.get(name);
-        // TODO: probably do not need to create executionState on client as it is not used
         if (!executionState) {
             executionState = { status: 'pending', state: {} };
             this.execution.set(name, executionState);

package/lib/actions/actionPageRunner.browser.browser.js

@@ -1,6 +1,5 @@
 import { isSilentError } from '@tinkoff/errors';
-import { ACTION_PARAMETERS, isTramvaiAction } from '@tramvai/core';
-import { Deferred } from './deferred/deferred.browser.js';
+import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
 
 const DEFAULT_PAYLOAD = {};
 class ActionPageRunner {
@@ -11,27 +10,9 @@ class ActionPageRunner {
     runActions(actions, stopRunAtError = () => false) {
         return this.deps.executionContextManager.withContext(this.deps.commandLineExecutionContext(), { name: 'pageActions', values: { pageActions: true } }, async (executionContext) => {
             const actionMapper = (action) => {
-                const isDeferredAction = ACTION_PARAMETERS in action && action[ACTION_PARAMETERS].deferred;
-                if (isDeferredAction && !this.deps.deferredMap.get(action.name)) {
-                    const deferred = new Deferred();
-                    // avoid unhandled promise rejection
-                    deferred.promise.catch(() => { });
-                    this.deps.deferredMap.set(action.name, deferred);
-                }
                 return Promise.resolve()
                     .then(() => {
                     const promise = this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD);
-                    if (isDeferredAction) {
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        const deferred = this.deps.deferredMap.get(action.name);
-                        // @todo check always: true actions
-                        if (!deferred.isResolved() && !deferred.isRejected()) {
-                            // eslint-disable-next-line promise/no-nesting
-                            promise.then(deferred.resolve).catch(deferred.reject);
-                        }
-                        // eslint-disable-next-line promise/no-return-wrap
-                        return Promise.resolve();
-                    }
                     return promise;
                 })
                     .catch((error) => {

package/lib/actions/actionPageRunner.browser.d.ts

@@ -1,6 +1,6 @@
 import type { Action, ExtractDependencyType, TramvaiAction } from '@tramvai/core';
 import type { LOGGER_TOKEN } from '@tramvai/module-log';
-import type { COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import type { COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import type { ActionExecution } from './actionExecution';
 export declare class ActionPageRunner {
     private deps;
@@ -10,7 +10,6 @@ export declare class ActionPageRunner {
         executionContextManager: ExtractDependencyType<typeof EXECUTION_CONTEXT_MANAGER_TOKEN>;
         commandLineExecutionContext: ExtractDependencyType<typeof COMMAND_LINE_EXECUTION_CONTEXT_TOKEN>;
         logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
-        deferredMap: ExtractDependencyType<typeof DEFERRED_ACTIONS_MAP_TOKEN>;
     });
     runActions(actions: Array<Action | TramvaiAction<any[], any, any>>, stopRunAtError?: (error: Error) => boolean): Promise<void>;
 }

package/lib/actions/actionPageRunner.es.js

@@ -1,7 +1,6 @@
 import { ACTION_PARAMETERS, isTramvaiAction } from '@tramvai/core';
 import { isSilentError } from '@tinkoff/errors';
 import { actionServerStateEvent } from './actionTramvaiReducer.es.js';
-import { Deferred } from './deferred/deferred.es.js';
 import { generateDeferredResolve, generateDeferredReject } from './deferred/clientScriptsUtils.es.js';
 
 const DEFAULT_PAYLOAD = {};
@@ -38,22 +37,14 @@ class ActionPageRunner {
                 };
                 const actionMapper = (action) => {
                     const isDeferredAction = ACTION_PARAMETERS in action && action[ACTION_PARAMETERS].deferred;
-                    if (isDeferredAction && !this.deferredMap.get(action.name)) {
-                        const deferred = new Deferred();
-                        // avoid unhandled promise rejection
-                        deferred.promise.catch(() => { });
-                        this.deferredMap.set(action.name, deferred);
-                    }
                     return Promise.resolve()
                         .then(() => {
                         var _a;
                         const promise = this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD);
                         if (isDeferredAction) {
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            const deferred = this.deferredMap.get(action.name);
-                            // eslint-disable-next-line promise/no-nesting
-                            promise.then(deferred.resolve).catch(deferred.reject);
                             (_a = this.responseTaskManager) === null || _a === void 0 ? void 0 : _a.push(async () => {
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                const deferred = this.deferredMap.get(action.name);
                                 // scripts will already be present on the page HTML
                                 if (deferred.isResolved() || deferred.isRejected()) {
                                     return;
@@ -75,8 +66,6 @@ class ActionPageRunner {
                                     })}</script>`);
                                 });
                             });
-                            // eslint-disable-next-line promise/no-return-wrap
-                            return Promise.resolve();
                         }
                         return promise;
                     })

package/lib/actions/actionPageRunner.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var core = require('@tramvai/core');
 var errors = require('@tinkoff/errors');
 var actionTramvaiReducer = require('./actionTramvaiReducer.js');
-var deferred = require('./deferred/deferred.js');
 var clientScriptsUtils = require('./deferred/clientScriptsUtils.js');
 
 const DEFAULT_PAYLOAD = {};
@@ -42,22 +41,14 @@ class ActionPageRunner {
                 };
                 const actionMapper = (action) => {
                     const isDeferredAction = core.ACTION_PARAMETERS in action && action[core.ACTION_PARAMETERS].deferred;
-                    if (isDeferredAction && !this.deferredMap.get(action.name)) {
-                        const deferred$1 = new deferred.Deferred();
-                        // avoid unhandled promise rejection
-                        deferred$1.promise.catch(() => { });
-                        this.deferredMap.set(action.name, deferred$1);
-                    }
                     return Promise.resolve()
                         .then(() => {
                         var _a;
                         const promise = this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD);
                         if (isDeferredAction) {
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            const deferred = this.deferredMap.get(action.name);
-                            // eslint-disable-next-line promise/no-nesting
-                            promise.then(deferred.resolve).catch(deferred.reject);
                             (_a = this.responseTaskManager) === null || _a === void 0 ? void 0 : _a.push(async () => {
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                const deferred = this.deferredMap.get(action.name);
                                 // scripts will already be present on the page HTML
                                 if (deferred.isResolved() || deferred.isRejected()) {
                                     return;
@@ -79,8 +70,6 @@ class ActionPageRunner {
                                     })}</script>`);
                                 });
                             });
-                            // eslint-disable-next-line promise/no-return-wrap
-                            return Promise.resolve();
                         }
                         return promise;
                     })

package/lib/actions/conditions/dynamic.browser.js

@@ -0,0 +1,21 @@
+import { isServer, isBrowser } from './helpers.browser.js';
+
+// @todo make this behaviour default in next tramvai major version?
+const dynamicCondition = {
+    key: 'dynamicCondition',
+    fn: (checker) => {
+        if (checker.conditions.dynamic) {
+            if (isServer) {
+                checker.setState({ environment: 'server' });
+            }
+            if (!checker.getState() || checker.getState().environment === 'browser') {
+                checker.allow();
+            }
+            if (isBrowser) {
+                checker.setState({ environment: 'browser' });
+            }
+        }
+    },
+};
+
+export { dynamicCondition };

package/lib/actions/conditions/dynamic.d.ts

@@ -0,0 +1,2 @@
+import type { ActionCondition } from '@tramvai/tokens-common';
+export declare const dynamicCondition: ActionCondition;

package/lib/actions/conditions/dynamic.es.js

@@ -0,0 +1,21 @@
+import { isServer, isBrowser } from './helpers.es.js';
+
+// @todo make this behaviour default in next tramvai major version?
+const dynamicCondition = {
+    key: 'dynamicCondition',
+    fn: (checker) => {
+        if (checker.conditions.dynamic) {
+            if (isServer) {
+                checker.setState({ environment: 'server' });
+            }
+            if (!checker.getState() || checker.getState().environment === 'browser') {
+                checker.allow();
+            }
+            if (isBrowser) {
+                checker.setState({ environment: 'browser' });
+            }
+        }
+    },
+};
+
+export { dynamicCondition };

package/lib/actions/conditions/dynamic.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers = require('./helpers.js');
+
+// @todo make this behaviour default in next tramvai major version?
+const dynamicCondition = {
+    key: 'dynamicCondition',
+    fn: (checker) => {
+        if (checker.conditions.dynamic) {
+            if (helpers.isServer) {
+                checker.setState({ environment: 'server' });
+            }
+            if (!checker.getState() || checker.getState().environment === 'browser') {
+                checker.allow();
+            }
+            if (helpers.isBrowser) {
+                checker.setState({ environment: 'browser' });
+            }
+        }
+    },
+};
+
+exports.dynamicCondition = dynamicCondition;

package/lib/actions/deferred/await.browser.js

@@ -10,7 +10,7 @@ function Await({ action, children, error, }) {
     if (!action.deferred) {
         throw new Error(`Action ${action.name} is not deferred`);
     }
-    // for SPA-transitions, when actions will be called after rendering
+    // will be created when spa run actions mode is "after"
     if (!deferred) {
         deferred = new Deferred();
         // avoid unhandled promise rejection

package/lib/actions/deferred/await.es.js

@@ -10,7 +10,7 @@ function Await({ action, children, error, }) {
     if (!action.deferred) {
         throw new Error(`Action ${action.name} is not deferred`);
     }
-    // for SPA-transitions, when actions will be called after rendering
+    // will be created when spa run actions mode is "after"
     if (!deferred) {
         deferred = new Deferred();
         // avoid unhandled promise rejection

package/lib/actions/deferred/await.js

@@ -14,7 +14,7 @@ function Await({ action, children, error, }) {
     if (!action.deferred) {
         throw new Error(`Action ${action.name} is not deferred`);
     }
-    // for SPA-transitions, when actions will be called after rendering
+    // will be created when spa run actions mode is "after"
     if (!deferred$1) {
         deferred$1 = new deferred.Deferred();
         // avoid unhandled promise rejection

package/lib/actions/deferred/deferred.browser.js

@@ -1,6 +1,20 @@
 class Deferred {
     constructor() {
-        this.promise = new Promise((resolve, reject) => {
+        this.promise = this.initPromise();
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+    reset() {
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    }
+    initPromise() {
+        return new Promise((resolve, reject) => {
             this.resolve = (value) => {
                 this.resolveData = value;
                 resolve(value);
@@ -11,12 +25,6 @@ class Deferred {
             };
         });
     }
-    isResolved() {
-        return typeof this.resolveData !== 'undefined';
-    }
-    isRejected() {
-        return typeof this.rejectReason !== 'undefined';
-    }
 }
 
 export { Deferred };

package/lib/actions/deferred/deferred.d.ts

@@ -8,4 +8,6 @@ export declare class Deferred implements IDeferred {
     constructor();
     isResolved(): boolean;
     isRejected(): boolean;
+    reset(): void;
+    private initPromise;
 }

package/lib/actions/deferred/deferred.es.js

@@ -1,6 +1,20 @@
 class Deferred {
     constructor() {
-        this.promise = new Promise((resolve, reject) => {
+        this.promise = this.initPromise();
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+    reset() {
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    }
+    initPromise() {
+        return new Promise((resolve, reject) => {
             this.resolve = (value) => {
                 this.resolveData = value;
                 resolve(value);
@@ -11,12 +25,6 @@ class Deferred {
             };
         });
     }
-    isResolved() {
-        return typeof this.resolveData !== 'undefined';
-    }
-    isRejected() {
-        return typeof this.rejectReason !== 'undefined';
-    }
 }
 
 export { Deferred };

package/lib/actions/deferred/deferred.inline.d.ts

@@ -1,2 +1,2 @@
 import type { Deferred } from '@tramvai/tokens-common';
-export declare function __Deferred(this: Deferred): void;
+export declare function __Deferred(this: Deferred & Record<string, any>): void;

package/lib/actions/deferred/deferred.inline.es.js

@@ -1,20 +1,28 @@
 function __Deferred() {
-    this.promise = new Promise((resolve, reject) => {
-        this.resolve = (value) => {
-            this.resolveData = value;
-            resolve(value);
-        };
-        this.reject = (reason) => {
-            this.rejectReason = reason;
-            reject(reason);
-        };
-    });
+    this.initPromise = () => {
+        return new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.resolveData = value;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.rejectReason = reason;
+                reject(reason);
+            };
+        });
+    };
+    this.promise = this.initPromise();
     this.isResolved = () => {
         return typeof this.resolveData !== 'undefined';
     };
     this.isRejected = () => {
         return typeof this.rejectReason !== 'undefined';
     };
+    this.reset = () => {
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    };
 }
 
 export { __Deferred };

package/lib/actions/deferred/deferred.inline.js

@@ -3,22 +3,30 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function __Deferred() {
-    this.promise = new Promise((resolve, reject) => {
-        this.resolve = (value) => {
-            this.resolveData = value;
-            resolve(value);
-        };
-        this.reject = (reason) => {
-            this.rejectReason = reason;
-            reject(reason);
-        };
-    });
+    this.initPromise = () => {
+        return new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.resolveData = value;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.rejectReason = reason;
+                reject(reason);
+            };
+        });
+    };
+    this.promise = this.initPromise();
     this.isResolved = () => {
         return typeof this.resolveData !== 'undefined';
     };
     this.isRejected = () => {
         return typeof this.rejectReason !== 'undefined';
     };
+    this.reset = () => {
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    };
 }
 
 exports.__Deferred = __Deferred;

package/lib/actions/deferred/deferred.js

@@ -4,7 +4,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 class Deferred {
     constructor() {
-        this.promise = new Promise((resolve, reject) => {
+        this.promise = this.initPromise();
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+    reset() {
+        this.resolveData = undefined;
+        this.rejectReason = undefined;
+        this.promise = this.initPromise();
+    }
+    initPromise() {
+        return new Promise((resolve, reject) => {
             this.resolve = (value) => {
                 this.resolveData = value;
                 resolve(value);
@@ -15,12 +29,6 @@ class Deferred {
             };
         });
     }
-    isResolved() {
-        return typeof this.resolveData !== 'undefined';
-    }
-    isRejected() {
-        return typeof this.rejectReason !== 'undefined';
-    }
 }
 
 exports.Deferred = Deferred;

package/lib/actions/deferred/providers.browser.browser.js

@@ -5,6 +5,9 @@ const providers = [
     provide({
         provide: DEFERRED_ACTIONS_MAP_TOKEN,
         useFactory: () => {
+            if (!window.__TRAMVAI_DEFERRED_ACTIONS) {
+                window.__TRAMVAI_DEFERRED_ACTIONS = {};
+            }
             return {
                 get(key) {
                     return window.__TRAMVAI_DEFERRED_ACTIONS[key];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-common",
-  "version": "2.145.1",
+  "version": "2.146.1",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -36,28 +36,28 @@
     "@tinkoff/pubsub": "0.5.7",
     "@tinkoff/url": "0.8.6",
     "@tramvai/safe-strings": "0.5.12",
-    "@tramvai/experiments": "2.145.1",
-    "@tramvai/module-cookie": "2.145.1",
-    "@tramvai/module-environment": "2.145.1",
-    "@tramvai/module-log": "2.145.1",
-    "@tramvai/tokens-child-app": "2.145.1",
-    "@tramvai/tokens-core-private": "2.145.1",
-    "@tramvai/tokens-common": "2.145.1",
-    "@tramvai/tokens-render": "2.145.1",
-    "@tramvai/tokens-server-private": "2.145.1",
-    "@tramvai/types-actions-state-context": "2.145.1",
+    "@tramvai/experiments": "2.146.1",
+    "@tramvai/module-cookie": "2.146.1",
+    "@tramvai/module-environment": "2.146.1",
+    "@tramvai/module-log": "2.146.1",
+    "@tramvai/tokens-child-app": "2.146.1",
+    "@tramvai/tokens-core-private": "2.146.1",
+    "@tramvai/tokens-common": "2.146.1",
+    "@tramvai/tokens-render": "2.146.1",
+    "@tramvai/tokens-server-private": "2.146.1",
+    "@tramvai/types-actions-state-context": "2.146.1",
     "hoist-non-react-statics": "^3.3.1",
     "node-abort-controller": "^3.0.1"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.15",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "2.145.1",
-    "@tramvai/core": "2.145.1",
-    "@tramvai/papi": "2.145.1",
-    "@tramvai/react": "2.145.1",
-    "@tramvai/state": "2.145.1",
-    "@tramvai/tokens-server": "2.145.1",
+    "@tramvai/cli": "2.146.1",
+    "@tramvai/core": "2.146.1",
+    "@tramvai/papi": "2.146.1",
+    "@tramvai/react": "2.146.1",
+    "@tramvai/state": "2.146.1",
+    "@tramvai/tokens-server": "2.146.1",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },