@tramvai/module-common 3.16.0 → 3.19.0

package/lib/actions/actionExecution.browser.js

@@ -7,7 +7,7 @@ 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';
+import { Deferred } from './deferred/deferred.inline.browser.js';
 
 const EMPTY_DEPS = {};
 const getParameters = (action) => action[ACTION_PARAMETERS];

package/lib/actions/actionExecution.es.js

@@ -7,7 +7,7 @@ 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';
+import { Deferred } from './deferred/deferred.inline.es.js';
 
 const EMPTY_DEPS = {};
 const getParameters = (action) => action[ACTION_PARAMETERS];

package/lib/actions/actionExecution.js

@@ -11,7 +11,7 @@ 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');
+var deferred_inline = require('./deferred/deferred.inline.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -63,10 +63,10 @@ class ActionExecution {
         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();
+            const deferred = new deferred_inline.Deferred();
             // avoid unhandled promise rejection
-            deferred$1.promise.catch(() => { });
-            this.deferredActionsMap.set(action.name, deferred$1);
+            deferred.promise.catch(() => { });
+            this.deferredActionsMap.set(action.name, deferred);
         }
         executionState.status = 'pending';
         return this.executionContextManager.withContext(executionContext, {

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

@@ -1,7 +1,7 @@
 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';
+import { Deferred } from './deferred.inline.browser.js';
 
 function Await({ action, children, error, }) {
     const deferredMap = useDi(DEFERRED_ACTIONS_MAP_TOKEN);

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

@@ -1,7 +1,7 @@
 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';
+import { Deferred } from './deferred.inline.es.js';
 
 function Await({ action, children, error, }) {
     const deferredMap = useDi(DEFERRED_ACTIONS_MAP_TOKEN);

package/lib/actions/deferred/await.js

@@ -5,36 +5,36 @@ 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');
+var deferred_inline = require('./deferred.inline.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);
+    let deferred = deferredMap.get(action.name);
     if (!action.deferred) {
         throw new Error(`Action ${action.name} is not deferred`);
     }
     // will be created when spa run actions mode is "after"
-    if (!deferred$1) {
-        deferred$1 = new deferred.Deferred();
+    if (!deferred) {
+        deferred = new deferred_inline.Deferred();
         // avoid unhandled promise rejection
-        deferred$1.promise.catch(() => { });
-        deferredMap.set(action.name, deferred$1);
+        deferred.promise.catch(() => { });
+        deferredMap.set(action.name, deferred);
     }
-    if (deferred$1.isResolved()) {
-        return children(deferred$1.resolveData);
+    if (deferred.isResolved()) {
+        return children(deferred.resolveData);
     }
-    if (deferred$1.isRejected()) {
-        const reason = deferred$1.rejectReason instanceof Error
-            ? deferred$1.rejectReason
+    if (deferred.isRejected()) {
+        const reason = deferred.rejectReason instanceof Error
+            ? deferred.rejectReason
             : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                safeStrings.deserializeError(deferred$1.rejectReason);
+                safeStrings.deserializeError(deferred.rejectReason);
         if (!error) {
             throw reason;
         }
         return error(reason);
     }
-    throw deferred$1.promise;
+    throw deferred.promise;
 }
 
 exports.Await = Await;

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

@@ -0,0 +1,30 @@
+class Deferred {
+    constructor() {
+        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();
+        };
+        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();
+    }
+}
+
+export { Deferred };

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

@@ -1,3 +1,14 @@
-import type { Deferred } from '@tramvai/tokens-common';
-export declare function __Deferred(this: Deferred & Record<string, any>): void;
+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;
+    isResolved: () => boolean;
+    isRejected: () => boolean;
+    reset: () => void;
+    private initPromise;
+    constructor();
+}
 //# sourceMappingURL=deferred.inline.d.ts.map

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

@@ -1,28 +1,30 @@
-function __Deferred() {
-    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;
+class Deferred {
+    constructor() {
+        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();
+        };
+        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();
-    };
+    }
 }
 
-export { __Deferred };
+export { Deferred };

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

@@ -2,31 +2,33 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function __Deferred() {
-    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;
+class Deferred {
+    constructor() {
+        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();
+        };
+        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();
-    };
+    }
 }
 
-exports.__Deferred = __Deferred;
+exports.Deferred = Deferred;

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

@@ -1,7 +1,7 @@
 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 { Deferred } from './deferred.inline.es.js';
 import { generateDeferredResolve, generateDeferredReject } from './clientScriptsUtils.es.js';
 
 const providers = [
@@ -18,7 +18,7 @@ const providers = [
                     resourcesRegistry.register({
                         slot: ResourceSlot.HEAD_CORE_SCRIPTS,
                         type: ResourceType.inlineScript,
-                        payload: `window.__Deferred = ${__Deferred}
+                        payload: `window.__Deferred = ${Deferred}
 window.__TRAMVAI_DEFERRED_ACTIONS = {};`,
                     });
                     deferredMap.forEach((deferred, key) => {

package/lib/actions/deferred/providers.js

@@ -22,7 +22,7 @@ const providers = [
                     resourcesRegistry.register({
                         slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
                         type: tokensRender.ResourceType.inlineScript,
-                        payload: `window.__Deferred = ${deferred_inline.__Deferred}
+                        payload: `window.__Deferred = ${deferred_inline.Deferred}
 window.__TRAMVAI_DEFERRED_ACTIONS = {};`,
                     });
                     deferredMap.forEach((deferred, key) => {

package/lib/index.browser.js

@@ -1,7 +1,7 @@
 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 { Deferred } from './actions/deferred/deferred.inline.browser.js';
 export { Await } from './actions/deferred/await.browser.js';
 export { ExecutionContextManager } from './executionContext/executionContextManager.browser.js';
 import './actions/ActionModule.browser.js';

package/lib/index.d.ts

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

package/lib/index.es.js

@@ -1,7 +1,7 @@
 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 { Deferred } from './actions/deferred/deferred.inline.es.js';
 export { Await } from './actions/deferred/await.es.js';
 export { ExecutionContextManager } from './executionContext/executionContextManager.es.js';
 import './actions/ActionModule.es.js';

package/lib/index.js

@@ -5,7 +5,7 @@ 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 deferred_inline = require('./actions/deferred/deferred.inline.js');
 var _await = require('./actions/deferred/await.js');
 var executionContextManager = require('./executionContext/executionContextManager.js');
 require('./actions/ActionModule.js');
@@ -31,7 +31,7 @@ Object.defineProperty(exports, 'CommandModule', {
 	get: function () { return CommandModule.CommandModule; }
 });
 exports.ActionExecution = actionExecution.ActionExecution;
-exports.Deferred = deferred.Deferred;
+exports.Deferred = deferred_inline.Deferred;
 exports.Await = _await.Await;
 exports.ExecutionContextManager = executionContextManager.ExecutionContextManager;
 exports.createConsumerContext = createConsumerContext.createConsumerContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-common",
-  "version": "3.16.0",
+  "version": "3.19.0",
   "description": "",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -30,35 +30,35 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@tinkoff/errors": "0.4.1",
+    "@tinkoff/errors": "0.4.2",
     "@tinkoff/hook-runner": "0.5.1",
     "@tinkoff/lru-cache-nano": "^7.9.0",
     "@akashbabu/lfu-cache": "1.0.2",
     "@tinkoff/pubsub": "0.6.1",
     "@tinkoff/url": "0.9.2",
     "@tramvai/safe-strings": "0.6.2",
-    "@tramvai/experiments": "3.16.0",
-    "@tramvai/module-cookie": "3.16.0",
-    "@tramvai/module-environment": "3.16.0",
-    "@tramvai/module-log": "3.16.0",
-    "@tramvai/tokens-child-app": "3.16.0",
-    "@tramvai/tokens-core-private": "3.16.0",
-    "@tramvai/tokens-common": "3.16.0",
-    "@tramvai/tokens-render": "3.16.0",
-    "@tramvai/tokens-server-private": "3.16.0",
-    "@tramvai/types-actions-state-context": "3.16.0",
+    "@tramvai/experiments": "3.19.0",
+    "@tramvai/module-cookie": "3.19.0",
+    "@tramvai/module-environment": "3.19.0",
+    "@tramvai/module-log": "3.19.0",
+    "@tramvai/tokens-child-app": "3.19.0",
+    "@tramvai/tokens-core-private": "3.19.0",
+    "@tramvai/tokens-common": "3.19.0",
+    "@tramvai/tokens-render": "3.19.0",
+    "@tramvai/tokens-server-private": "3.19.0",
+    "@tramvai/types-actions-state-context": "3.19.0",
     "hoist-non-react-statics": "^3.3.1",
     "node-abort-controller": "^3.0.1"
   },
   "peerDependencies": {
     "@tinkoff/dippy": "0.9.1",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "3.16.0",
-    "@tramvai/core": "3.16.0",
-    "@tramvai/papi": "3.16.0",
-    "@tramvai/react": "3.16.0",
-    "@tramvai/state": "3.16.0",
-    "@tramvai/tokens-server": "3.16.0",
+    "@tramvai/cli": "3.19.0",
+    "@tramvai/core": "3.19.0",
+    "@tramvai/papi": "3.19.0",
+    "@tramvai/react": "3.19.0",
+    "@tramvai/state": "3.19.0",
+    "@tramvai/tokens-server": "3.19.0",
     "react": ">=16.14.0",
     "tslib": "^2.4.0"
   },

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

@@ -1,30 +0,0 @@
-class Deferred {
-    constructor() {
-        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);
-            };
-            this.reject = (reason) => {
-                this.rejectReason = reason;
-                reject(reason);
-            };
-        });
-    }
-}
-
-export { Deferred };

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

@@ -1,14 +0,0 @@
-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;
-    reset(): void;
-    private initPromise;
-}
-//# sourceMappingURL=deferred.d.ts.map

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

@@ -1,30 +0,0 @@
-class Deferred {
-    constructor() {
-        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);
-            };
-            this.reject = (reason) => {
-                this.rejectReason = reason;
-                reject(reason);
-            };
-        });
-    }
-}
-
-export { Deferred };

package/lib/actions/deferred/deferred.js

@@ -1,34 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-class Deferred {
-    constructor() {
-        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);
-            };
-            this.reject = (reason) => {
-                this.rejectReason = reason;
-                reject(reason);
-            };
-        });
-    }
-}
-
-exports.Deferred = Deferred;