@tramvai/module-child-app 2.70.0 → 2.72.0

package/lib/server.js

@@ -4,1088 +4,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
 var core = require('@tramvai/core');
-var dippy = require('@tinkoff/dippy');
+var providers = require('./shared/providers.js');
+var providers$1 = require('./server/providers.js');
 var tokensChildApp = require('@tramvai/tokens-child-app');
-var tokensCommon = require('@tramvai/tokens-common');
-var tokensRender = require('@tramvai/tokens-render');
-var tokensRouter = require('@tramvai/tokens-router');
-var react$1 = require('@tramvai/react');
-var flatten = require('@tinkoff/utils/array/flatten');
-var state = require('@tramvai/state');
-var jsxRuntime = require('react/jsx-runtime');
-var react = require('react');
-var applyOrReturn = require('@tinkoff/utils/function/applyOrReturn');
-var envValidators = require('@tinkoff/env-validators');
-var safeStrings = require('@tramvai/safe-strings');
-var moduleLoaderServer = require('@tinkoff/module-loader-server');
-var noop = require('@tinkoff/utils/function/noop');
-var moduleRouter = require('@tramvai/module-router');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-var applyOrReturn__default = /*#__PURE__*/_interopDefaultLegacy(applyOrReturn);
-var noop__default = /*#__PURE__*/_interopDefaultLegacy(noop);
-
-const getChildProviders$2 = (appDi) => {
-    return [
-        core.provide({
-            provide: tokensChildApp.commandLineListTokens.resolvePageDeps,
-            multi: true,
-            useFactory: ({ actionRunner, actions }) => {
-                return function childAppRunActions() {
-                    return actionRunner.runActions(flatten__default["default"](actions));
-                };
-            },
-            deps: {
-                actionRunner: tokensCommon.ACTION_PAGE_RUNNER_TOKEN,
-                actions: tokensChildApp.CHILD_APP_INTERNAL_ACTION_TOKEN,
-            },
-        }),
-    ];
-};
-
-const getChildProviders$1 = (appDi) => {
-    const logger = appDi.get(tokensCommon.LOGGER_TOKEN);
-    return [
-        core.provide({
-            provide: tokensCommon.LOGGER_TOKEN,
-            useValue: Object.assign((opts) => {
-                return logger('child-app').child(opts);
-            }, logger),
-        }),
-        core.provide({
-            provide: tokensRender.RENDER_SLOTS,
-            multi: true,
-            useValue: [],
-        }),
-        ...getChildProviders$2(),
-    ];
-};
-
-const commonModuleStubs = [
-    tokensCommon.DISPATCHER_TOKEN,
-    tokensCommon.STORE_TOKEN,
-    tokensCommon.CONTEXT_TOKEN,
-    core.COMMAND_LINE_RUNNER_TOKEN,
-].map((provide) => {
-    return {
-        provide,
-        useFactory: () => {
-            throw Object.assign(new Error('Pure usage of the token is not allowed inside ChildApp, please add `CommonChildAppModule` from module `@tramvai/module-common` to your ChildApp'), { code: 'E_STUB' });
-        },
-    };
-});
-
-const validateChildAppProvider = (provider) => {
-    if (provider.provide.name === tokensCommon.ENV_USED_TOKEN.name) {
-        throw new Error(`child-app Cannot use 'ENV_USED_TOKEN' as envs should be controlled by the root-app.
-Consider passing configs from the root-app to child-app explicitly and remove defining 'ENV_USED_TOKEN' in the child-app itself.
-You can still use 'ENV_MANAGER_TOKEN' in child-app to get env values`);
-    }
-};
-
-class SingletonDiManager {
-    constructor({ logger, appDi, loader, }) {
-        this.cache = new Map();
-        this.log = logger('child-app:singleton-di-manager');
-        this.appDi = appDi;
-        this.loader = loader;
-    }
-    getChildDi(config) {
-        const { key, tag } = config;
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
-        try {
-            const di = this.resolveDi(config);
-            if (di && tag !== 'debug') {
-                this.cache.set(key, di);
-            }
-            return di;
-        }
-        catch (error) {
-            this.log.error({
-                event: 'resolve-di-fail',
-                error,
-                config,
-            });
-        }
-    }
-    forEachChildDi(cb) {
-        this.cache.forEach((di) => {
-            cb(di);
-        });
-    }
-    resolveDi(config) {
-        const children = this.loader.get(config);
-        if (!children) {
-            return;
-        }
-        const di = new dippy.Container([
-            {
-                provide: tokensChildApp.CHILD_APP_INTERNAL_CONFIG_TOKEN,
-                useValue: config,
-            },
-            {
-                provide: tokensChildApp.IS_CHILD_APP_DI_TOKEN,
-                useValue: true,
-            },
-        ], this.appDi);
-        const { modules = [], providers = [], actions = [] } = children;
-        // add providers on the Singleton Level to make it possible to reuse providers from the root-app Container
-        const childProviders = getChildProviders$1(this.appDi);
-        childProviders.forEach((provider) => {
-            di.register(provider);
-        });
-        const resolvedModules = core.walkOfModules(modules);
-        resolvedModules.forEach((mod) => {
-            const moduleParameters = core.getModuleParameters(mod);
-            moduleParameters.providers.forEach((provider) => {
-                di.register(provider);
-            });
-        });
-        providers.forEach((provider) => {
-            if (process.env.NODE_ENV === 'development') {
-                validateChildAppProvider(provider);
-            }
-            di.register(provider);
-        });
-        di.register({
-            provide: tokensChildApp.CHILD_APP_INTERNAL_ACTION_TOKEN,
-            multi: true,
-            useValue: actions,
-        });
-        const borrowTokens = di.get({ token: tokensChildApp.CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN, optional: true });
-        if (borrowTokens) {
-            flatten__default["default"](borrowTokens).forEach((token) => {
-                di.borrowToken(this.appDi, token);
-            });
-        }
-        commonModuleStubs.forEach((stub) => {
-            if (!di.has(stub.provide)) {
-                di.register(stub);
-            }
-        });
-        return di;
-    }
-}
-
-const getChildProviders = (appDi) => {
-    const parentDispatcherContext = appDi.get(tokensCommon.DISPATCHER_CONTEXT_TOKEN);
-    return [
-        core.provide({
-            provide: tokensCommon.DISPATCHER_CONTEXT_TOKEN,
-            useFactory: ({ dispatcher, middlewares, initialState, parentAllowedStores }) => {
-                return new state.ChildDispatcherContext({
-                    dispatcher,
-                    // context will be set later by the CONTEXT_TOKEN
-                    context: {},
-                    initialState: initialState !== null && initialState !== void 0 ? initialState : { stores: [] },
-                    middlewares: flatten__default["default"](middlewares || []),
-                    parentDispatcherContext,
-                    parentAllowedStores: flatten__default["default"](parentAllowedStores || []),
-                });
-            },
-            deps: {
-                dispatcher: tokensCommon.DISPATCHER_TOKEN,
-                middlewares: { token: tokensCommon.STORE_MIDDLEWARE, optional: true },
-                initialState: { token: tokensCommon.INITIAL_APP_STATE_TOKEN, optional: true },
-                parentAllowedStores: {
-                    token: tokensChildApp.CHILD_APP_INTERNAL_ROOT_STATE_ALLOWED_STORE_TOKEN,
-                    optional: true,
-                },
-            },
-        }),
-    ];
-};
-
-class DiManager {
-    constructor({ appDi, loader, singletonDiManager, }) {
-        this.cache = new Map();
-        this.appDi = appDi;
-        this.loader = loader;
-        this.singletonDiManager = singletonDiManager;
-    }
-    getChildDi(config) {
-        const { key } = config;
-        if (this.cache.has(key)) {
-            return this.cache.get(key);
-        }
-        const di = this.resolveDi(config);
-        di && this.cache.set(key, di);
-        return di;
-    }
-    forEachChildDi(cb) {
-        this.cache.forEach((di) => {
-            cb(di);
-        });
-    }
-    resolveDi(config) {
-        const children = this.loader.get(config);
-        if (!children) {
-            return;
-        }
-        const singletonDi = this.singletonDiManager.getChildDi(config);
-        if (!singletonDi) {
-            return;
-        }
-        const di = new dippy.ChildContainer(singletonDi, this.appDi);
-        // add providers on the Request Level to make it possible to reuse providers from the root-app ChildContainer
-        const childProviders = getChildProviders(this.appDi);
-        childProviders.forEach((provider) => {
-            di.register(provider);
-        });
-        return di;
-    }
-}
-
-class CommandLineRunner {
-    constructor({ logger, rootCommandLineRunner, diManager, }) {
-        this.log = logger('child-app:command-line-runner');
-        this.rootCommandLineRunner = rootCommandLineRunner;
-        this.diManager = diManager;
-    }
-    async run(type, status, config) {
-        const di = this.diManager.getChildDi(config);
-        if (!di) {
-            return;
-        }
-        try {
-            const commandLineRunner = di.get({ token: core.COMMAND_LINE_RUNNER_TOKEN, optional: true });
-            if (commandLineRunner && commandLineRunner !== this.rootCommandLineRunner) {
-                // TODO:child-app create independent metrics instance for child apps
-                // for now just reuse metrics implementation from root as otherwise it fails after attempt to create metrics instance with the same name
-                // @ts-ignore
-                commandLineRunner.metricsInstance = this.rootCommandLineRunner.metricsInstance;
-                await commandLineRunner.run(type, status, [], di);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'E_STUB') {
-                this.log.error({
-                    event: 'run-failed',
-                    error,
-                    type,
-                    status,
-                    config,
-                });
-            }
-        }
-    }
-}
-
-const setPreloaded = state.createEvent('child-app set preloaded');
-const initialState = {
-    preloaded: [],
-};
-const ChildAppStore = state.createReducer('child-app', initialState).on(setPreloaded, (_, preloaded) => {
-    return {
-        preloaded,
-    };
-});
-
-const RenderContext = react.createContext(null);
-
-const extendRender = ({ renderManager, }) => {
-    return (render) => {
-        return jsxRuntime.jsx(RenderContext.Provider, { value: renderManager, children: render });
-    };
-};
-
-const initModuleFederation = async (container, scope = 'default') => {
-    if (container) {
-        await container.init(__webpack_share_scopes__[scope]);
-        return;
-    }
-    await __webpack_init_sharing__('default');
-    // currently module federation has problems with external modules
-    // and unfourtanelly react and react-dom are marked as externals in defaults
-    // fill sharedScope manually here
-    const shareScope = __webpack_share_scopes__[scope];
-    if (!shareScope.react) {
-        shareScope.react = {
-            '*': {
-                get: () => () => require('react'),
-                from: 'tramvai-mf-fix',
-                eager: true,
-                loaded: true,
-            },
-        };
-    }
-    if (!shareScope['react-dom']) {
-        shareScope['react-dom'] = {
-            '*': {
-                get: () => () => require('react-dom'),
-                from: 'tramvai-mf-fix',
-                eager: true,
-                loaded: true,
-            },
-        };
-    }
-    if (process.env.NODE_ENV === 'development') {
-        // explicitly add react/jsx-runtime to support production builds of the child-app in dev mode
-        if (!shareScope['react/jsx-runtime']) {
-            shareScope['react/jsx-runtime'] = {
-                '*': {
-                    get: () => () => require('react/jsx-runtime'),
-                    from: 'tramvai-mf-fix',
-                    eager: true,
-                    loaded: true,
-                },
-            };
-        }
-    }
-};
-const getModuleFederation = async (container, name = 'entry') => {
-    return container.get(name);
-};
-
-class ChildAppResolutionConfigManager {
-    constructor({ configs, logger, }) {
-        this.hasInitialized = false;
-        this.rawConfigs = configs !== null && configs !== void 0 ? configs : [];
-        this.mapping = new Map();
-        this.log = logger('child-app:resolution-config');
-    }
-    async init() {
-        if (this.hasInitialized) {
-            return;
-        }
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = (async () => {
-            const configs = await Promise.all(this.rawConfigs.map((rawConfig) => {
-                return Promise.resolve()
-                    .then(() => {
-                    return applyOrReturn__default["default"]([], rawConfig);
-                })
-                    .catch((error) => {
-                    this.log.error(error, 'Failed while resolving resolution config');
-                });
-            }));
-            flatten__default["default"](configs).forEach((config) => {
-                if (config) {
-                    this.mapping.set(config.name, config);
-                }
-            });
-            this.hasInitialized = true;
-        })();
-        return this.initPromise;
-    }
-    resolve({ name, version, tag = 'latest' }) {
-        var _a;
-        const fromMapping = this.mapping.get(name);
-        if (!fromMapping) {
-            return;
-        }
-        const cfg = fromMapping.byTag[tag];
-        if (process.env.NODE_ENV === 'development' && tag === 'debug' && !cfg) {
-            return {
-                baseUrl: 'http://localhost:4040/',
-                version: '0.0.0-stub',
-            };
-        }
-        return {
-            ...cfg,
-            baseUrl: (_a = cfg.baseUrl) !== null && _a !== void 0 ? _a : fromMapping.baseUrl,
-            version: version !== null && version !== void 0 ? version : cfg.version,
-        };
-    }
-}
-
-const sharedProviders = [
-    core.provide({
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: ChildAppStore,
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.init,
-        multi: true,
-        useValue: () => initModuleFederation(),
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
-        useClass: ChildAppResolutionConfigManager,
-        deps: {
-            configs: { token: tokensChildApp.CHILD_APP_RESOLUTION_CONFIGS_TOKEN, optional: true },
-            logger: tokensCommon.LOGGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.resolvePageDeps,
-        multi: true,
-        useFactory: ({ resolutionConfigManager }) => {
-            return async function fallbackResolutionConfigManagerInit() {
-                await resolutionConfigManager.init();
-            };
-        },
-        deps: {
-            resolutionConfigManager: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
-        useFactory: ({ envManager, logger, rootBaseUrl, resolutionConfigManager }) => {
-            const rawEnv = envManager.get('CHILD_APP_DEBUG');
-            const log = logger('child-app:resolve-config');
-            const debug = new Map();
-            rawEnv === null || rawEnv === void 0 ? void 0 : rawEnv.split(';').reduce((acc, entry) => {
-                const [name, url] = entry.split('=');
-                return acc.set(name, url);
-            }, debug);
-            return (request) => {
-                var _a, _b;
-                const { name, tag = debug.has(name) ? 'debug' : 'latest' } = request;
-                const req = { name, tag, version: request.version };
-                const config = resolutionConfigManager.resolve(req);
-                if (!config) {
-                    log.error(`Child-app "${name}" with tag "${tag}" has not found`);
-                    return;
-                }
-                const { version, baseUrl: configBaseUrl, client, server, css, withoutCss } = config;
-                const baseUrl = (_b = (_a = debug.get(name)) !== null && _a !== void 0 ? _a : configBaseUrl) !== null && _b !== void 0 ? _b : rootBaseUrl;
-                if (!baseUrl) {
-                    throw new Error('CHILD_APP_EXTERNAL_URL was not defined');
-                }
-                return {
-                    name,
-                    tag,
-                    version,
-                    key: `${name}@${version}`,
-                    server: {
-                        entry: `${baseUrl}${name}/${name}_server@${version}.js`,
-                        ...server,
-                    },
-                    client: {
-                        baseUrl: `${baseUrl}${name}/`,
-                        entry: `${baseUrl}${name}/${name}_client@${version}.js`,
-                        ...client,
-                    },
-                    css: withoutCss
-                        ? undefined
-                        : {
-                            entry: `${baseUrl}${name}/${name}@${version}.css`,
-                            ...css,
-                        },
-                };
-            };
-        },
-        deps: {
-            envManager: tokensCommon.ENV_MANAGER_TOKEN,
-            logger: tokensCommon.LOGGER_TOKEN,
-            rootBaseUrl: tokensChildApp.CHILD_APP_RESOLVE_BASE_URL_TOKEN,
-            resolutionConfigManager: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_RESOLVE_BASE_URL_TOKEN,
-        useFactory: ({ envManager }) => {
-            return envManager.get('CHILD_APP_EXTERNAL_URL');
-        },
-        deps: {
-            envManager: tokensCommon.ENV_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
-        scope: dippy.Scope.SINGLETON,
-        useClass: SingletonDiManager,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            appDi: dippy.DI_TOKEN,
-            loader: tokensChildApp.CHILD_APP_LOADER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-        useClass: DiManager,
-        deps: {
-            appDi: dippy.DI_TOKEN,
-            loader: tokensChildApp.CHILD_APP_LOADER_TOKEN,
-            singletonDiManager: tokensChildApp.CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
-        useClass: CommandLineRunner,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            rootCommandLineRunner: core.COMMAND_LINE_RUNNER_TOKEN,
-            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.resolvePageDeps,
-        useFactory: ({ pageService, preloadManager }) => {
-            return async function preloadChildAppByComponent() {
-                var _a, _b, _c, _d, _e, _f;
-                const [layoutComponent, nestedLayoutComponent, pageComponent] = await Promise.all([
-                    react$1.resolveLazyComponent(pageService.resolveComponentFromConfig('layout')),
-                    react$1.resolveLazyComponent(pageService.resolveComponentFromConfig('nestedLayout')),
-                    react$1.resolveLazyComponent(pageService.resolveComponentFromConfig('page')),
-                ]);
-                await Promise.all([
-                    ...((_b = (_a = layoutComponent === null || layoutComponent === void 0 ? void 0 : layoutComponent.childApps) === null || _a === void 0 ? void 0 : _a.map((request) => preloadManager.preload(request))) !== null && _b !== void 0 ? _b : []),
-                    ...((_d = (_c = nestedLayoutComponent === null || nestedLayoutComponent === void 0 ? void 0 : nestedLayoutComponent.childApps) === null || _c === void 0 ? void 0 : _c.map((request) => preloadManager.preload(request))) !== null && _d !== void 0 ? _d : []),
-                    ...((_f = (_e = pageComponent === null || pageComponent === void 0 ? void 0 : pageComponent.childApps) === null || _e === void 0 ? void 0 : _e.map((request) => preloadManager.preload(request))) !== null && _f !== void 0 ? _f : []),
-                ]);
-            };
-        },
-        multi: true,
-        deps: {
-            pageService: tokensRouter.PAGE_SERVICE_TOKEN,
-            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.generatePage,
-        multi: true,
-        useFactory: ({ preloadManager }) => {
-            return function childAppPageRender() {
-                preloadManager.pageRender();
-            };
-        },
-        deps: {
-            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.clear,
-        multi: true,
-        useFactory: ({ preloader }) => {
-            return function childAppClear() {
-                return preloader.clearPreloaded();
-            };
-        },
-        deps: {
-            preloader: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensCommon.REGISTER_CLEAR_CACHE_TOKEN,
-        multi: true,
-        useFactory: ({ diManager }) => {
-            return (type) => {
-                diManager.forEachChildDi((di) => {
-                    var _a;
-                    const clearCache = di.get({ token: tokensCommon.CLEAR_CACHE_TOKEN, optional: true });
-                    if (clearCache) {
-                        // first if child-app has its own CLEAR_CACHE_TOKEN implementation use only it
-                        return clearCache(type);
-                    }
-                    // otherwise pick up any REGISTER_CLEAR_CACHE_TOKEN hooks and call it
-                    const registeredClearCache = (_a = di.get({
-                        token: tokensCommon.REGISTER_CLEAR_CACHE_TOKEN,
-                        optional: true,
-                    })) !== null && _a !== void 0 ? _a : [];
-                    return Promise.all(registeredClearCache.map((clear) => clear(type)));
-                });
-            };
-        },
-        deps: {
-            diManager: tokensChildApp.CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensRender.EXTEND_RENDER,
-        multi: true,
-        useFactory: extendRender,
-        deps: {
-            renderManager: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensCommon.ENV_USED_TOKEN,
-        multi: true,
-        useValue: [
-            {
-                key: 'CHILD_APP_DEBUG',
-                dehydrate: true,
-                optional: true,
-            },
-        ],
-    }),
-];
-
-class Loader {
-    resolve(entry) {
-        return entry.default;
-    }
-}
-
-class ServerLoader extends Loader {
-    constructor({ logger, createCache, }) {
-        super();
-        this.initializedMap = new WeakMap();
-        const cache = createCache('memory', {
-            ttl: 1000 * 60 * 60 * 24 * 5,
-            max: 20,
-        });
-        this.internalLoadCache = cache;
-        this.loader = new moduleLoaderServer.ServerLoader({
-            cache,
-            log: logger('child-app:loader'),
-        });
-    }
-    async load(config) {
-        await this.loader.resolveByUrl(config.server.entry, {
-            codePrefix: `var ASSETS_PREFIX="${config.client.baseUrl}";`,
-            displayName: config.name,
-            kind: 'child-app',
-        });
-        await this.init(config);
-        if (config.tag === 'debug') {
-            setTimeout(() => {
-                this.internalLoadCache.set(config.server.entry, null);
-            }, 10000);
-        }
-        return this.get(config);
-    }
-    async init(config) {
-        const container = this.loader.getByUrl(config.server.entry);
-        if (container) {
-            await initModuleFederation(container, 'default');
-            const factory = (await getModuleFederation(container, 'entry'));
-            const entry = factory();
-            this.initializedMap.set(container, entry);
-        }
-    }
-    get(config) {
-        const container = this.loader.getByUrl(config.server.entry);
-        return container && this.resolve(this.initializedMap.get(container));
-    }
-}
-
-class PreloadManager {
-    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, }) {
-        this.shouldRunImmediately = false;
-        this.map = new Map();
-        this.preloadMap = new Map();
-        this.loader = loader;
-        this.runner = runner;
-        this.stateManager = stateManager;
-        this.resolutionConfigManager = resolutionConfigManager;
-        this.resolveFullConfig = resolveFullConfig;
-    }
-    async preload(request) {
-        await this.resolutionConfigManager.init();
-        const config = this.resolveFullConfig(request);
-        if (!config) {
-            return;
-        }
-        const { key } = config;
-        if (this.map.has(key)) {
-            await this.map.get(key);
-            return;
-        }
-        const promise = this.loader
-            .load(config)
-            .catch(() => {
-            // Actual error will be logged by the internals of this.loader
-        })
-            .then(() => {
-            if (this.shouldRunImmediately) {
-                return this.run('customer', config);
-            }
-        })
-            .then(() => config);
-        this.map.set(key, promise);
-        this.preloadMap.set(config.key, config);
-        if (this.shouldRunImmediately) {
-            await promise;
-        }
-    }
-    isPreloaded(request) {
-        const config = this.resolveFullConfig(request);
-        return !!config && this.map.has(config.key);
-    }
-    async runPreloaded() {
-        this.shouldRunImmediately = true;
-        const promises = [];
-        this.map.forEach((childAppPromise) => {
-            promises.push((async () => {
-                await this.run('customer', await childAppPromise);
-            })());
-        });
-        await Promise.all(promises);
-    }
-    pageRender() { }
-    async clearPreloaded() {
-        const promises = [];
-        this.map.forEach((childAppPromise) => {
-            promises.push((async () => {
-                await this.run('clear', await childAppPromise);
-            })());
-        });
-        await Promise.all(promises);
-    }
-    getPreloadedList() {
-        return Array.from(this.preloadMap.values());
-    }
-    async run(status, config) {
-        const childApp = this.loader.get(config);
-        if (!childApp) {
-            return;
-        }
-        await this.runner.run('server', status, config);
-        await this.stateManager.registerChildApp(config);
-    }
-}
-
-const executeRootStateSubscriptions = ({ store, diManager, }) => {
-    return (render) => {
-        const state = store.getState();
-        diManager.forEachChildDi((di) => {
-            const subscriptions = di.get({
-                token: tokensChildApp.CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN,
-                optional: true,
-            });
-            subscriptions === null || subscriptions === void 0 ? void 0 : subscriptions.forEach((sub) => {
-                sub.listener(state);
-            });
-        });
-        return render;
-    };
-};
-class StateManager {
-    constructor({ logger, diManager, }) {
-        this.state = Object.create(null);
-        this.log = logger('child-app:state-manager');
-        this.diManager = diManager;
-    }
-    registerChildApp(config) {
-        const di = this.diManager.getChildDi(config);
-        const { key } = config;
-        if (!di) {
-            return;
-        }
-        try {
-            const context = di.get(tokensCommon.CONTEXT_TOKEN);
-            this.state[key] = context.dehydrate().dispatcher;
-        }
-        catch (error) {
-            if (error.code !== 'E_STUB') {
-                this.log.error({
-                    event: 'get-state-failed',
-                    config,
-                });
-            }
-        }
-    }
-    getState() {
-        return this.state;
-    }
-}
-
-class RenderManager {
-    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
-        this.hasRenderedSet = new Set();
-        this.log = logger('child-app:render');
-        this.preloadManager = preloadManager;
-        this.diManager = diManager;
-        this.resolveFullConfig = resolveFullConfig;
-    }
-    getChildDi(request) {
-        const config = this.resolveFullConfig(request);
-        if (!config) {
-            throw new Error(`Child app "${request.name}" not found`);
-        }
-        this.hasRenderedSet.add(config.key);
-        if (this.preloadManager.isPreloaded(request)) {
-            return [this.diManager.getChildDi(config), undefined];
-        }
-        this.log.warn({
-            message: 'Child-app has been used but not preloaded before React render',
-            request,
-        });
-        return [undefined, undefined];
-    }
-    clear() {
-        const preloadedList = this.preloadManager.getPreloadedList();
-        for (const request of preloadedList) {
-            const config = this.resolveFullConfig(request);
-            if (!config || !this.hasRenderedSet.has(config.key)) {
-                this.log.warn({
-                    message: 'Child-app has been preloaded but not used in React render',
-                    request,
-                });
-            }
-        }
-        this.hasRenderedSet.clear();
-    }
-}
-
-const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, preloadManager, }) => {
-    const log = logger('child-app:render:slots');
-    const result = [];
-    preloadManager.getPreloadedList().forEach((requestConfig) => {
-        var _a;
-        const config = resolveFullConfig(requestConfig);
-        if (!config) {
-            return;
-        }
-        const di = diManager.getChildDi(config);
-        result.push({
-            type: tokensRender.ResourceType.script,
-            slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
-            payload: config.client.entry,
-            attrs: {
-                'data-critical': 'true',
-            },
-        });
-        if (config.css) {
-            result.push({
-                type: tokensRender.ResourceType.style,
-                slot: tokensRender.ResourceSlot.HEAD_CORE_STYLES,
-                payload: (_a = config.css.entry) !== null && _a !== void 0 ? _a : null,
-                attrs: {
-                    'data-critical': 'true',
-                },
-            });
-        }
-        if (!di) {
-            return;
-        }
-        try {
-            const renderSlots = di.get({ token: tokensRender.RENDER_SLOTS, optional: true });
-            if (renderSlots) {
-                result.push(...renderSlots);
-            }
-        }
-        catch (error) {
-            log.error({
-                event: 'get-slots-failed',
-                config: requestConfig,
-            });
-        }
-    });
-    return result;
-};
-
-const GLOBAL_CHILD_STATE = '__TRAMVAI_CHILD_STATE__';
-
-const serverProviders = [
-    core.provide({
-        provide: tokensCommon.ENV_USED_TOKEN,
-        multi: true,
-        useValue: [
-            {
-                key: 'CHILD_APP_EXTERNAL_URL',
-                optional: true,
-                validator: envValidators.combineValidators([envValidators.isUrl, envValidators.endsWith('/')]),
-            },
-        ],
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_LOADER_TOKEN,
-        useClass: ServerLoader,
-        scope: dippy.Scope.SINGLETON,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            createCache: tokensCommon.CREATE_CACHE_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
-        useClass: StateManager,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-            resourcesRegistry: tokensRender.RESOURCES_REGISTRY,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        useClass: PreloadManager,
-        deps: {
-            loader: tokensChildApp.CHILD_APP_LOADER_TOKEN,
-            runner: tokensChildApp.CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
-            stateManager: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
-            resolutionConfigManager: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
-            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensRender.RENDER_SLOTS,
-        multi: true,
-        useFactory: ({ stateManager, preloader, store }) => {
-            store.dispatch(setPreloaded(preloader.getPreloadedList()));
-            return {
-                type: tokensRender.ResourceType.asIs,
-                slot: tokensRender.ResourceSlot.BODY_END,
-                payload: `<script id="${GLOBAL_CHILD_STATE}" type="application/json">${safeStrings.safeStringify(stateManager.getState())}</script>`,
-            };
-        },
-        deps: {
-            stateManager: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
-            preloader: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-            store: tokensCommon.STORE_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensRender.RENDER_SLOTS,
-        multi: true,
-        useFactory: registerChildAppRenderSlots,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
-            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensRender.EXTEND_RENDER,
-        multi: true,
-        // execute subscription right before render to get the last actual data
-        useFactory: executeRootStateSubscriptions,
-        deps: {
-            store: tokensCommon.STORE_TOKEN,
-            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
-        useClass: RenderManager,
-        deps: {
-            logger: tokensCommon.LOGGER_TOKEN,
-            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
-            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.resolvePageDeps,
-        multi: true,
-        useFactory: ({ preloader }) => {
-            return function childAppRunPreloaded() {
-                return preloader.runPreloaded();
-            };
-        },
-        deps: {
-            preloader: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
-        },
-    }),
-    core.provide({
-        provide: core.commandLineListTokens.clear,
-        multi: true,
-        useFactory: ({ renderManager }) => {
-            return function childAppRenderClear() {
-                renderManager.clear();
-            };
-        },
-        deps: {
-            renderManager: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
-        },
-    }),
-];
-
-const FailedChildAppFallback = ({ config: { name, version, tag, fallback: Fallback }, }) => {
-    const logger = react$1.useDi(tokensCommon.LOGGER_TOKEN);
-    const log = logger('child-app:render');
-    // On client-side hydration errors will be handled in `hydrateRoot` `onRecoverableError` property,
-    // and update errors will be handled in Error Boundaries.
-    //
-    // Also, this component never be rendered at client-side, and we check environment only for safety
-    // (server errors logic described here https://github.com/reactjs/rfcs/blob/main/text/0215-server-errors-in-react-18.md).
-    //
-    // On server-side, we still use `renderToString`,
-    // and need to manually log render errors for components, wrapped in Suspense Boundaries.
-    if (typeof window === 'undefined') {
-        log.error({
-            event: 'failed-render',
-            message: 'child-app failed to render, will try to recover during hydration',
-            name,
-            version,
-            tag,
-        });
-    }
-    return Fallback ? jsxRuntime.jsx(Fallback, {}) : null;
-};
-const ChildAppWrapper = ({ name, version, tag, props, fallback: Fallback, }) => {
-    const renderManager = react.useContext(RenderContext);
-    const logger = react$1.useDi(tokensCommon.LOGGER_TOKEN);
-    const log = logger('child-app:render');
-    const [maybeDi, maybePromiseDi] = react.useMemo(() => {
-        return renderManager.getChildDi({ name, version, tag });
-    }, [name, version, tag, renderManager]);
-    const [di, setDi] = react.useState(maybeDi);
-    const [promiseDi, setPromiseDi] = react.useState(maybePromiseDi);
-    react.useEffect(() => {
-        if (!di && promiseDi) {
-            // any errors with loading child-app should be handled in some other place
-            promiseDi
-                .then(setDi)
-                .finally(() => setPromiseDi(undefined))
-                .catch(noop__default["default"]);
-        }
-    }, [di, promiseDi]);
-    if (!di && promiseDi) {
-        // in case child-app was not rendered on ssr
-        // and we have to wait before it's loading
-        return Fallback ? jsxRuntime.jsx(Fallback, {}) : null;
-    }
-    if (!di) {
-        log.error({
-            event: 'not-found',
-            name,
-            version,
-            tag,
-            message: 'child-app was not initialized',
-        });
-        if (process.env.__TRAMVAI_CONCURRENT_FEATURES || typeof window !== 'undefined') {
-            throw new Error(`Child-app was not initialized, check the loading error for child-app "${name}"`);
-        }
-        return Fallback ? jsxRuntime.jsx(Fallback, {}) : null;
-    }
-    try {
-        const Cmp = di.get({ token: tokensChildApp.CHILD_APP_INTERNAL_RENDER_TOKEN, optional: true });
-        if (!Cmp) {
-            log.error({
-                event: 'empty-render',
-                message: 'Child-app does not provide render token',
-                name,
-                version,
-                tag,
-            });
-            return null;
-        }
-        return jsxRuntime.jsx(Cmp, { di: di, props: props });
-    }
-    catch (error) {
-        log.error({
-            event: 'get-render',
-            message: 'Cannot get render token from child-app',
-            error,
-            name,
-            version,
-            tag,
-        });
-        return null;
-    }
-};
-const ChildApp = react.memo((config) => {
-    const { fallback } = config;
-    const url = moduleRouter.useUrl();
-    const result = (jsxRuntime.jsx(react$1.UniversalErrorBoundary, { url: url, fallback: fallback, children: jsxRuntime.jsx(ChildAppWrapper, { ...config }) }));
-    if (process.env.__TRAMVAI_CONCURRENT_FEATURES) {
-        return jsxRuntime.jsx(react.Suspense, { fallback: jsxRuntime.jsx(FailedChildAppFallback, { config: config }), children: result });
-    }
-    return result;
-});
+var component = require('./shared/react/component.js');
 
 exports.ChildAppModule = class ChildAppModule {
 };
 exports.ChildAppModule = tslib.__decorate([
     core.Module({
         imports: [],
-        providers: [...sharedProviders, ...serverProviders],
+        providers: [...providers.sharedProviders, ...providers$1.serverProviders],
     })
 ], exports.ChildAppModule);
 
-exports.ChildApp = ChildApp;
+exports.ChildApp = component.ChildApp;
 Object.keys(tokensChildApp).forEach(function (k) {
     if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
         enumerable: true,