@tramvai/module-common 2.143.1 → 2.145.1

package/lib/actions/ActionModule.browser.js

@@ -1,6 +1,7 @@
 import { __decorate } from 'tslib';
-import { createToken, Module, provide, Scope, ACTIONS_LIST_TOKEN, DI_TOKEN } 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 } from '@tramvai/tokens-common';
+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 { SERVER_RESPONSE_TASK_MANAGER, SERVER_RESPONSE_STREAM } from '@tramvai/tokens-server-private';
 import { actionTramvaiReducer } from './actionTramvaiReducer.browser.js';
 import { ActionExecution } from './actionExecution.browser.js';
 import { ActionRegistry } from './actionRegistry.browser.js';
@@ -15,6 +16,7 @@ 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 { providers } from './deferred/providers.browser.browser.js';
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = createToken('limitActionGlobalTimeRun');
 let ActionModule = class ActionModule {
@@ -61,6 +63,9 @@ ActionModule = __decorate([
                     store: STORE_TOKEN,
                     limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
                     logger: LOGGER_TOKEN,
+                    deferredMap: DEFERRED_ACTIONS_MAP_TOKEN,
+                    responseTaskManager: optional(SERVER_RESPONSE_TASK_MANAGER),
+                    serverResponseStream: optional(SERVER_RESPONSE_STREAM),
                 },
             }),
             provide({
@@ -72,6 +77,7 @@ ActionModule = __decorate([
                 multi: true,
                 useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
             }),
+            ...providers,
         ],
     })
 ], ActionModule);

package/lib/actions/ActionModule.es.js

@@ -1,6 +1,7 @@
 import { __decorate } from 'tslib';
-import { createToken, Module, provide, Scope, ACTIONS_LIST_TOKEN, DI_TOKEN } 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 } from '@tramvai/tokens-common';
+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 { SERVER_RESPONSE_TASK_MANAGER, SERVER_RESPONSE_STREAM } from '@tramvai/tokens-server-private';
 import { actionTramvaiReducer } from './actionTramvaiReducer.es.js';
 import { ActionExecution } from './actionExecution.es.js';
 import { ActionRegistry } from './actionRegistry.es.js';
@@ -15,6 +16,7 @@ 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 { providers } from './deferred/providers.es.js';
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = createToken('limitActionGlobalTimeRun');
 let ActionModule = class ActionModule {
@@ -61,6 +63,9 @@ ActionModule = __decorate([
                     store: STORE_TOKEN,
                     limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
                     logger: LOGGER_TOKEN,
+                    deferredMap: DEFERRED_ACTIONS_MAP_TOKEN,
+                    responseTaskManager: optional(SERVER_RESPONSE_TASK_MANAGER),
+                    serverResponseStream: optional(SERVER_RESPONSE_STREAM),
                 },
             }),
             provide({
@@ -72,6 +77,7 @@ ActionModule = __decorate([
                 multi: true,
                 useValue: [alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser],
             }),
+            ...providers,
         ],
     })
 ], ActionModule);

package/lib/actions/ActionModule.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
 var actionTramvaiReducer = require('./actionTramvaiReducer.js');
 var actionExecution = require('./actionExecution.js');
 var actionRegistry = require('./actionRegistry.js');
@@ -14,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 providers = require('./deferred/providers.js');
 
 const LIMIT_ACTION_GLOBAL_TIME_RUN = core.createToken('limitActionGlobalTimeRun');
 exports.ActionModule = class ActionModule {
@@ -60,6 +62,9 @@ exports.ActionModule = tslib.__decorate([
                     store: tokensCommon.STORE_TOKEN,
                     limitTime: LIMIT_ACTION_GLOBAL_TIME_RUN,
                     logger: tokensCommon.LOGGER_TOKEN,
+                    deferredMap: tokensCommon.DEFERRED_ACTIONS_MAP_TOKEN,
+                    responseTaskManager: core.optional(tokensServerPrivate.SERVER_RESPONSE_TASK_MANAGER),
+                    serverResponseStream: core.optional(tokensServerPrivate.SERVER_RESPONSE_STREAM),
                 },
             }),
             core.provide({
@@ -71,6 +76,7 @@ exports.ActionModule = tslib.__decorate([
                 multi: true,
                 useValue: [always.alwaysCondition, onlyServer.onlyServer, onlyBrowser.onlyBrowser, pageServer.pageServer, pageBrowser.pageBrowser],
             }),
+            ...providers.providers,
         ],
     })
 ], exports.ActionModule);

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

@@ -1,5 +1,6 @@
 import { isSilentError } from '@tinkoff/errors';
-import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+import { ACTION_PARAMETERS, isTramvaiAction } from '@tramvai/core';
+import { Deferred } from './deferred/deferred.browser.js';
 
 const DEFAULT_PAYLOAD = {};
 class ActionPageRunner {
@@ -10,8 +11,29 @@ 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(() => this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD))
+                    .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) => {
                     var _a;
                     if (!isSilentError(error)) {

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

@@ -1,15 +1,16 @@
-import type { Action, TramvaiAction } from '@tramvai/core';
+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 } from '@tramvai/tokens-common';
+import type { COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
 import type { ActionExecution } from './actionExecution';
 export declare class ActionPageRunner {
     private deps;
-    log: ReturnType<typeof LOGGER_TOKEN>;
+    log: ReturnType<ExtractDependencyType<typeof LOGGER_TOKEN>>;
     constructor(deps: {
         actionExecution: ActionExecution;
-        executionContextManager: typeof EXECUTION_CONTEXT_MANAGER_TOKEN;
-        commandLineExecutionContext: typeof COMMAND_LINE_EXECUTION_CONTEXT_TOKEN;
-        logger: typeof LOGGER_TOKEN;
+        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.d.ts

@@ -1,5 +1,6 @@
 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';
+import type { LOGGER_TOKEN, ActionPageRunner as ActionPageRunnerInterface, STORE_TOKEN, EXECUTION_CONTEXT_MANAGER_TOKEN, COMMAND_LINE_EXECUTION_CONTEXT_TOKEN, ACTION_EXECUTION_TOKEN, DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import type { SERVER_RESPONSE_STREAM, SERVER_RESPONSE_TASK_MANAGER } from '@tramvai/tokens-server-private';
 declare module '@tramvai/tokens-common' {
     interface ExecutionContextValues {
         pageActions?: boolean;
@@ -8,6 +9,9 @@ declare module '@tramvai/tokens-common' {
 export declare class ActionPageRunner implements ActionPageRunnerInterface {
     private deps;
     private log;
+    private deferredMap;
+    private responseTaskManager;
+    private serverResponseStream;
     constructor(deps: {
         store: ExtractDependencyType<typeof STORE_TOKEN>;
         actionExecution: ExtractDependencyType<typeof ACTION_EXECUTION_TOKEN>;
@@ -15,6 +19,9 @@ export declare class ActionPageRunner implements ActionPageRunnerInterface {
         commandLineExecutionContext: ExtractDependencyType<typeof COMMAND_LINE_EXECUTION_CONTEXT_TOKEN>;
         limitTime: number;
         logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
+        deferredMap: ExtractDependencyType<typeof DEFERRED_ACTIONS_MAP_TOKEN>;
+        responseTaskManager: ExtractDependencyType<typeof SERVER_RESPONSE_TASK_MANAGER> | null;
+        serverResponseStream: ExtractDependencyType<typeof SERVER_RESPONSE_STREAM> | null;
     });
     runActions(actions: Array<Action | TramvaiAction<any[], any, any>>, stopRunAtError?: (error: Error) => boolean): Promise<void>;
     private syncStateActions;

package/lib/actions/actionPageRunner.es.js

@@ -1,12 +1,17 @@
-import { isTramvaiAction, ACTION_PARAMETERS } from '@tramvai/core';
+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 = {};
 class ActionPageRunner {
     constructor(deps) {
         this.deps = deps;
         this.log = deps.logger('action:action-page-runner');
+        this.deferredMap = deps.deferredMap;
+        this.responseTaskManager = deps.responseTaskManager;
+        this.serverResponseStream = deps.serverResponseStream;
     }
     // TODO stopRunAtError нужен только для редиректов на стороне сервера в экшенах. И нужно пересмотреть реализацию редиректов
     runActions(actions, stopRunAtError = () => false) {
@@ -32,8 +37,49 @@ class ActionPageRunner {
                     resolve();
                 };
                 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(() => this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD))
+                        .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 () => {
+                                // scripts will already be present on the page HTML
+                                if (deferred.isResolved() || deferred.isRejected()) {
+                                    return;
+                                }
+                                // eslint-disable-next-line promise/no-nesting
+                                await deferred.promise
+                                    .then((data) => {
+                                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                    this.serverResponseStream.push(`<script>${generateDeferredResolve({
+                                        key: action.name,
+                                        data,
+                                    })}</script>`);
+                                })
+                                    .catch((reason) => {
+                                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                    this.serverResponseStream.push(`<script>${generateDeferredReject({
+                                        key: action.name,
+                                        error: reason,
+                                    })}</script>`);
+                                });
+                            });
+                            // eslint-disable-next-line promise/no-return-wrap
+                            return Promise.resolve();
+                        }
+                        return promise;
+                    })
                         .catch((error) => {
                         var _a;
                         const isCriticalError = stopRunAtError(error);

package/lib/actions/actionPageRunner.js

@@ -5,12 +5,17 @@ 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 = {};
 class ActionPageRunner {
     constructor(deps) {
         this.deps = deps;
         this.log = deps.logger('action:action-page-runner');
+        this.deferredMap = deps.deferredMap;
+        this.responseTaskManager = deps.responseTaskManager;
+        this.serverResponseStream = deps.serverResponseStream;
     }
     // TODO stopRunAtError нужен только для редиректов на стороне сервера в экшенах. И нужно пересмотреть реализацию редиректов
     runActions(actions, stopRunAtError = () => false) {
@@ -36,8 +41,49 @@ class ActionPageRunner {
                     resolve();
                 };
                 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(() => this.deps.actionExecution.runInContext(executionContext, action, DEFAULT_PAYLOAD))
+                        .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 () => {
+                                // scripts will already be present on the page HTML
+                                if (deferred.isResolved() || deferred.isRejected()) {
+                                    return;
+                                }
+                                // eslint-disable-next-line promise/no-nesting
+                                await deferred.promise
+                                    .then((data) => {
+                                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                    this.serverResponseStream.push(`<script>${clientScriptsUtils.generateDeferredResolve({
+                                        key: action.name,
+                                        data,
+                                    })}</script>`);
+                                })
+                                    .catch((reason) => {
+                                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                    this.serverResponseStream.push(`<script>${clientScriptsUtils.generateDeferredReject({
+                                        key: action.name,
+                                        error: reason,
+                                    })}</script>`);
+                                });
+                            });
+                            // eslint-disable-next-line promise/no-return-wrap
+                            return Promise.resolve();
+                        }
+                        return promise;
+                    })
                         .catch((error) => {
                         var _a;
                         const isCriticalError = stopRunAtError(error);

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

@@ -0,0 +1,36 @@
+import { useDi } from '@tramvai/react';
+import { DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import { deserializeError } from '@tramvai/safe-strings';
+import { Deferred } from './deferred.browser.js';
+
+function Await({ action, children, error, }) {
+    const deferredMap = useDi(DEFERRED_ACTIONS_MAP_TOKEN);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    let deferred = deferredMap.get(action.name);
+    if (!action.deferred) {
+        throw new Error(`Action ${action.name} is not deferred`);
+    }
+    // for SPA-transitions, when actions will be called after rendering
+    if (!deferred) {
+        deferred = new Deferred();
+        // avoid unhandled promise rejection
+        deferred.promise.catch(() => { });
+        deferredMap.set(action.name, deferred);
+    }
+    if (deferred.isResolved()) {
+        return children(deferred.resolveData);
+    }
+    if (deferred.isRejected()) {
+        const reason = deferred.rejectReason instanceof Error
+            ? deferred.rejectReason
+            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                deserializeError(deferred.rejectReason);
+        if (!error) {
+            throw reason;
+        }
+        return error(reason);
+    }
+    throw deferred.promise;
+}
+
+export { Await };

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

@@ -0,0 +1,6 @@
+import type { TramvaiAction } from '@tramvai/types-actions-state-context';
+export declare function Await<Result>({ action, children, error, }: {
+    action: TramvaiAction<any, Result, any>;
+    children: (data: Result extends Promise<infer R> ? R : Result) => JSX.Element;
+    error?: (reason: any) => JSX.Element;
+}): JSX.Element;

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

@@ -0,0 +1,36 @@
+import { useDi } from '@tramvai/react';
+import { DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import { deserializeError } from '@tramvai/safe-strings';
+import { Deferred } from './deferred.es.js';
+
+function Await({ action, children, error, }) {
+    const deferredMap = useDi(DEFERRED_ACTIONS_MAP_TOKEN);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    let deferred = deferredMap.get(action.name);
+    if (!action.deferred) {
+        throw new Error(`Action ${action.name} is not deferred`);
+    }
+    // for SPA-transitions, when actions will be called after rendering
+    if (!deferred) {
+        deferred = new Deferred();
+        // avoid unhandled promise rejection
+        deferred.promise.catch(() => { });
+        deferredMap.set(action.name, deferred);
+    }
+    if (deferred.isResolved()) {
+        return children(deferred.resolveData);
+    }
+    if (deferred.isRejected()) {
+        const reason = deferred.rejectReason instanceof Error
+            ? deferred.rejectReason
+            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                deserializeError(deferred.rejectReason);
+        if (!error) {
+            throw reason;
+        }
+        return error(reason);
+    }
+    throw deferred.promise;
+}
+
+export { Await };

package/lib/actions/deferred/await.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('@tramvai/react');
+var tokensCommon = require('@tramvai/tokens-common');
+var safeStrings = require('@tramvai/safe-strings');
+var deferred = require('./deferred.js');
+
+function Await({ action, children, error, }) {
+    const deferredMap = react.useDi(tokensCommon.DEFERRED_ACTIONS_MAP_TOKEN);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    let deferred$1 = deferredMap.get(action.name);
+    if (!action.deferred) {
+        throw new Error(`Action ${action.name} is not deferred`);
+    }
+    // for SPA-transitions, when actions will be called after rendering
+    if (!deferred$1) {
+        deferred$1 = new deferred.Deferred();
+        // avoid unhandled promise rejection
+        deferred$1.promise.catch(() => { });
+        deferredMap.set(action.name, deferred$1);
+    }
+    if (deferred$1.isResolved()) {
+        return children(deferred$1.resolveData);
+    }
+    if (deferred$1.isRejected()) {
+        const reason = deferred$1.rejectReason instanceof Error
+            ? deferred$1.rejectReason
+            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                safeStrings.deserializeError(deferred$1.rejectReason);
+        if (!error) {
+            throw reason;
+        }
+        return error(reason);
+    }
+    throw deferred$1.promise;
+}
+
+exports.Await = Await;

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

@@ -0,0 +1,8 @@
+export declare const generateDeferredResolve: ({ key, data }: {
+    key: string;
+    data: any;
+}) => string;
+export declare const generateDeferredReject: ({ key, error }: {
+    key: string;
+    error: Error;
+}) => string;

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

@@ -0,0 +1,10 @@
+import { safeStringifyJSON, serializeError } from '@tramvai/safe-strings';
+
+const generateDeferredResolve = ({ key, data }) => {
+    return `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].resolve(${safeStringifyJSON(data)});`;
+};
+const generateDeferredReject = ({ key, error }) => {
+    return `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].reject(${safeStringifyJSON(serializeError(error))});`;
+};
+
+export { generateDeferredReject, generateDeferredResolve };

package/lib/actions/deferred/clientScriptsUtils.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var safeStrings = require('@tramvai/safe-strings');
+
+const generateDeferredResolve = ({ key, data }) => {
+    return `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].resolve(${safeStrings.safeStringifyJSON(data)});`;
+};
+const generateDeferredReject = ({ key, error }) => {
+    return `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].reject(${safeStrings.safeStringifyJSON(safeStrings.serializeError(error))});`;
+};
+
+exports.generateDeferredReject = generateDeferredReject;
+exports.generateDeferredResolve = generateDeferredResolve;

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

@@ -0,0 +1,22 @@
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.resolveData = value;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.rejectReason = reason;
+                reject(reason);
+            };
+        });
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+}
+
+export { Deferred };

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

@@ -0,0 +1,11 @@
+import type { Deferred as IDeferred } from '@tramvai/tokens-common';
+export declare class Deferred implements IDeferred {
+    promise: Promise<any>;
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+    resolveData: any;
+    rejectReason: any;
+    constructor();
+    isResolved(): boolean;
+    isRejected(): boolean;
+}

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

@@ -0,0 +1,22 @@
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.resolveData = value;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.rejectReason = reason;
+                reject(reason);
+            };
+        });
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+}
+
+export { Deferred };

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

@@ -0,0 +1,2 @@
+import type { Deferred } from '@tramvai/tokens-common';
+export declare function __Deferred(this: Deferred): void;

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

@@ -0,0 +1,20 @@
+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.isResolved = () => {
+        return typeof this.resolveData !== 'undefined';
+    };
+    this.isRejected = () => {
+        return typeof this.rejectReason !== 'undefined';
+    };
+}
+
+export { __Deferred };

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

@@ -0,0 +1,24 @@
+'use strict';
+
+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.isResolved = () => {
+        return typeof this.resolveData !== 'undefined';
+    };
+    this.isRejected = () => {
+        return typeof this.rejectReason !== 'undefined';
+    };
+}
+
+exports.__Deferred = __Deferred;

package/lib/actions/deferred/deferred.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.resolveData = value;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.rejectReason = reason;
+                reject(reason);
+            };
+        });
+    }
+    isResolved() {
+        return typeof this.resolveData !== 'undefined';
+    }
+    isRejected() {
+        return typeof this.rejectReason !== 'undefined';
+    }
+}
+
+exports.Deferred = Deferred;

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

@@ -0,0 +1,28 @@
+import { provide } from '@tramvai/core';
+import { DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+
+const providers = [
+    provide({
+        provide: DEFERRED_ACTIONS_MAP_TOKEN,
+        useFactory: () => {
+            return {
+                get(key) {
+                    return window.__TRAMVAI_DEFERRED_ACTIONS[key];
+                },
+                set(key, value) {
+                    window.__TRAMVAI_DEFERRED_ACTIONS[key] = value;
+                },
+                has(key) {
+                    return key in window.__TRAMVAI_DEFERRED_ACTIONS;
+                },
+                forEach(callback) {
+                    Object.keys(window.__TRAMVAI_DEFERRED_ACTIONS).forEach((key) => {
+                        callback(window.__TRAMVAI_DEFERRED_ACTIONS[key], key);
+                    });
+                },
+            };
+        },
+    }),
+];
+
+export { providers };

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

@@ -0,0 +1,9 @@
+import type { Deferred } from '@tramvai/tokens-common';
+declare global {
+    interface Window {
+        __TRAMVAI_DEFERRED_ACTIONS: Record<string, Deferred>;
+    }
+}
+export declare const providers: import("@tramvai/core").Provider<unknown, import("@tramvai/tokens-common").DeferredActionsMap & {
+    __type?: "base token" | undefined;
+}>[];

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

@@ -0,0 +1,20 @@
+export declare const providers: (import("@tramvai/core").Provider<unknown, import("@tramvai/tokens-common").DeferredActionsMap & {
+    __type?: "base token" | undefined;
+}> | import("@tramvai/core").Provider<{
+    resourcesRegistry: import("@tramvai/tokens-render").ResourcesRegistry & {
+        __type?: "base token" | undefined;
+    };
+    deferredMap: import("@tramvai/tokens-common").DeferredActionsMap & {
+        __type?: "base token" | undefined;
+    };
+    renderMode: {
+        token: ("sync" & {
+            __type?: "base token" | undefined;
+        }) | ("streaming" & {
+            __type?: "base token" | undefined;
+        });
+        optional: true;
+    };
+}, import("@tramvai/core").Command & {
+    __type?: "multi token" | undefined;
+}>)[];

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

@@ -0,0 +1,59 @@
+import { provide, commandLineListTokens, optional } from '@tramvai/core';
+import { ResourceSlot, ResourceType, RESOURCES_REGISTRY, REACT_SERVER_RENDER_MODE } from '@tramvai/tokens-render';
+import { DEFERRED_ACTIONS_MAP_TOKEN } from '@tramvai/tokens-common';
+import { __Deferred } from './deferred.inline.es.js';
+import { generateDeferredResolve, generateDeferredReject } from './clientScriptsUtils.es.js';
+
+const providers = [
+    provide({
+        provide: DEFERRED_ACTIONS_MAP_TOKEN,
+        useFactory: () => new Map(),
+    }),
+    provide({
+        provide: commandLineListTokens.generatePage,
+        useFactory: ({ resourcesRegistry, deferredMap, renderMode }) => {
+            // eslint-disable-next-line max-statements
+            return async function render() {
+                if (renderMode === 'streaming') {
+                    resourcesRegistry.register({
+                        slot: ResourceSlot.HEAD_CORE_SCRIPTS,
+                        type: ResourceType.inlineScript,
+                        payload: `window.__Deferred = ${__Deferred}
+window.__TRAMVAI_DEFERRED_ACTIONS = {};`,
+                    });
+                    deferredMap.forEach((deferred, key) => {
+                        const scriptLines = [
+                            `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'] = new __Deferred();`,
+                            `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].promise.catch(function(){});`,
+                        ];
+                        if (deferred.isResolved()) {
+                            scriptLines.push(generateDeferredResolve({
+                                key,
+                                data: deferred.resolveData,
+                            }));
+                        }
+                        else if (deferred.isRejected()) {
+                            scriptLines.push(generateDeferredReject({
+                                key,
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                error: deferred.rejectReason,
+                            }));
+                        }
+                        resourcesRegistry.register({
+                            slot: ResourceSlot.HEAD_CORE_SCRIPTS,
+                            type: ResourceType.inlineScript,
+                            payload: scriptLines.join('\n'),
+                        });
+                    });
+                }
+            };
+        },
+        deps: {
+            resourcesRegistry: RESOURCES_REGISTRY,
+            deferredMap: DEFERRED_ACTIONS_MAP_TOKEN,
+            renderMode: optional(REACT_SERVER_RENDER_MODE),
+        },
+    }),
+];
+
+export { providers };

package/lib/actions/deferred/providers.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensRender = require('@tramvai/tokens-render');
+var tokensCommon = require('@tramvai/tokens-common');
+var deferred_inline = require('./deferred.inline.js');
+var clientScriptsUtils = require('./clientScriptsUtils.js');
+
+const providers = [
+    core.provide({
+        provide: tokensCommon.DEFERRED_ACTIONS_MAP_TOKEN,
+        useFactory: () => new Map(),
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.generatePage,
+        useFactory: ({ resourcesRegistry, deferredMap, renderMode }) => {
+            // eslint-disable-next-line max-statements
+            return async function render() {
+                if (renderMode === 'streaming') {
+                    resourcesRegistry.register({
+                        slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
+                        type: tokensRender.ResourceType.inlineScript,
+                        payload: `window.__Deferred = ${deferred_inline.__Deferred}
+window.__TRAMVAI_DEFERRED_ACTIONS = {};`,
+                    });
+                    deferredMap.forEach((deferred, key) => {
+                        const scriptLines = [
+                            `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'] = new __Deferred();`,
+                            `window.__TRAMVAI_DEFERRED_ACTIONS['${key}'].promise.catch(function(){});`,
+                        ];
+                        if (deferred.isResolved()) {
+                            scriptLines.push(clientScriptsUtils.generateDeferredResolve({
+                                key,
+                                data: deferred.resolveData,
+                            }));
+                        }
+                        else if (deferred.isRejected()) {
+                            scriptLines.push(clientScriptsUtils.generateDeferredReject({
+                                key,
+                                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                error: deferred.rejectReason,
+                            }));
+                        }
+                        resourcesRegistry.register({
+                            slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
+                            type: tokensRender.ResourceType.inlineScript,
+                            payload: scriptLines.join('\n'),
+                        });
+                    });
+                }
+            };
+        },
+        deps: {
+            resourcesRegistry: tokensRender.RESOURCES_REGISTRY,
+            deferredMap: tokensCommon.DEFERRED_ACTIONS_MAP_TOKEN,
+            renderMode: core.optional(tokensRender.REACT_SERVER_RENDER_MODE),
+        },
+    }),
+];
+
+exports.providers = providers;

package/lib/index.browser.js

@@ -1,6 +1,8 @@
 export { CommonModule } from './CommonModule.browser.js';
 export { CommandModule } from './command/CommandModule.browser.js';
 export { ActionExecution } from './actions/actionExecution.browser.js';
+export { Deferred } from './actions/deferred/deferred.browser.js';
+export { Await } from './actions/deferred/await.browser.js';
 export { ExecutionContextManager } from './executionContext/executionContextManager.browser.js';
 import './actions/ActionModule.browser.js';
 export { createConsumerContext } from './createConsumerContext/createConsumerContext.browser.js';

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 export { CommonModule } from './CommonModule';
 export { CommandModule } from './command/CommandModule';
 export { ActionExecution } from './actions/actionExecution';
+export { Deferred } from './actions/deferred/deferred';
+export { Await } from './actions/deferred/await';
 export { ExecutionContextManager } from './executionContext/executionContextManager';
 export { alwaysCondition, onlyServer, onlyBrowser, pageServer, pageBrowser, } from './actions/ActionModule';
 export { createConsumerContext } from './createConsumerContext/createConsumerContext';

package/lib/index.es.js

@@ -1,6 +1,8 @@
 export { CommonModule } from './CommonModule.es.js';
 export { CommandModule } from './command/CommandModule.es.js';
 export { ActionExecution } from './actions/actionExecution.es.js';
+export { Deferred } from './actions/deferred/deferred.es.js';
+export { Await } from './actions/deferred/await.es.js';
 export { ExecutionContextManager } from './executionContext/executionContextManager.es.js';
 import './actions/ActionModule.es.js';
 export { createConsumerContext } from './createConsumerContext/createConsumerContext.es.js';

package/lib/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var CommonModule = require('./CommonModule.js');
 var CommandModule = require('./command/CommandModule.js');
 var actionExecution = require('./actions/actionExecution.js');
+var deferred = require('./actions/deferred/deferred.js');
+var _await = require('./actions/deferred/await.js');
 var executionContextManager = require('./executionContext/executionContextManager.js');
 require('./actions/ActionModule.js');
 var createConsumerContext = require('./createConsumerContext/createConsumerContext.js');
@@ -28,6 +30,8 @@ Object.defineProperty(exports, 'CommandModule', {
 	get: function () { return CommandModule.CommandModule; }
 });
 exports.ActionExecution = actionExecution.ActionExecution;
+exports.Deferred = deferred.Deferred;
+exports.Await = _await.Await;
 exports.ExecutionContextManager = executionContextManager.ExecutionContextManager;
 exports.createConsumerContext = createConsumerContext.createConsumerContext;
 Object.defineProperty(exports, 'CommonChildAppModule', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-common",
-  "version": "2.143.1",
+  "version": "2.145.1",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -10,6 +10,7 @@
   ],
   "browser": {
     "./lib/actions/actionPageRunner.js": "./lib/actions/actionPageRunner.browser.js",
+    "./lib/actions/deferred/providers.js": "./lib/actions/deferred/providers.browser.js",
     "./lib/cache/serverProviders.js": "./lib/cache/clientProviders.js",
     "./lib/cache/cacheFactory.js": "./lib/cache/cacheFactory.browser.js",
     "./lib/index.es.js": "./lib/index.browser.js",
@@ -34,28 +35,29 @@
     "@akashbabu/lfu-cache": "1.0.2",
     "@tinkoff/pubsub": "0.5.7",
     "@tinkoff/url": "0.8.6",
-    "@tramvai/experiments": "2.143.1",
-    "@tramvai/module-cookie": "2.143.1",
-    "@tramvai/module-environment": "2.143.1",
-    "@tramvai/module-log": "2.143.1",
-    "@tramvai/tokens-child-app": "2.143.1",
-    "@tramvai/tokens-core-private": "2.143.1",
-    "@tramvai/tokens-common": "2.143.1",
-    "@tramvai/tokens-render": "2.143.1",
-    "@tramvai/tokens-server-private": "2.143.1",
-    "@tramvai/types-actions-state-context": "2.143.1",
+    "@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",
     "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.143.1",
-    "@tramvai/core": "2.143.1",
-    "@tramvai/papi": "2.143.1",
-    "@tramvai/react": "2.143.1",
-    "@tramvai/state": "2.143.1",
-    "@tramvai/tokens-server": "2.143.1",
+    "@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",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },