@tramvai/module-child-app 1.46.5

package/lib/server.es.js

@@ -0,0 +1,920 @@
+import { __decorate } from 'tslib';
+import { provide, COMMAND_LINE_RUNNER_TOKEN, walkOfModules, getModuleParameters, commandLineListTokens as commandLineListTokens$1, Module } from '@tramvai/core';
+import flatten from '@tinkoff/utils/array/flatten';
+import { Container, ChildContainer, Scope, DI_TOKEN } from '@tinkoff/dippy';
+import { commandLineListTokens, CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN, CHILD_APP_INTERNAL_ACTION_TOKEN, CHILD_APP_INTERNAL_CONFIG_TOKEN, IS_CHILD_APP_DI_TOKEN, CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN, CHILD_APP_GET_RESOLUTION_CONFIG_TOKEN, CHILD_APP_RESOLUTION_CONFIGS_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RESOLVE_BASE_URL_TOKEN, CHILD_APP_SINGLETON_DI_MANAGER_TOKEN, CHILD_APP_LOADER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_PRELOAD_EXTERNAL_CONFIG_TOKEN, CHILD_APP_INTERNAL_RENDER_TOKEN } from '@tramvai/tokens-child-app';
+export * from '@tramvai/tokens-child-app';
+import { ACTION_PAGE_RUNNER_TOKEN, CONTEXT_TOKEN, LOGGER_TOKEN, DISPATCHER_TOKEN, STORE_TOKEN, COMBINE_REDUCERS, ENV_MANAGER_TOKEN, REGISTER_CLEAR_CACHE_TOKEN, CLEAR_CACHE_TOKEN, ENV_USED_TOKEN, CREATE_CACHE_TOKEN } from '@tramvai/tokens-common';
+import { RENDER_SLOTS, EXTEND_RENDER, ResourceType, ResourceSlot, RESOURCES_REGISTRY, CUSTOM_RENDER } from '@tramvai/tokens-render';
+import { createEvent, createReducer } from '@tramvai/state';
+import React, { createContext, useContext, useMemo, useState, useEffect, createElement } from 'react';
+import { combineValidators, isUrl, endsWith } from '@tinkoff/env-validators';
+import { safeDehydrate } from '@tramvai/safe-strings';
+import { ServerLoader as ServerLoader$1 } from '@tinkoff/module-loader-server';
+import noop from '@tinkoff/utils/function/noop';
+import { renderToString } from 'react-dom/server';
+import { useDi } from '@tramvai/react';
+
+const getChildProviders$1 = (appDi) => {
+    const context = appDi.get(CONTEXT_TOKEN);
+    return [
+        {
+            provide: commandLineListTokens.customerStart,
+            multi: true,
+            useFactory: ({ subscriptions, }) => {
+                return function resolveRootStateForChild() {
+                    if (!subscriptions) {
+                        return;
+                    }
+                    const state = context.getState();
+                    return Promise.all(subscriptions.map((sub) => {
+                        return sub.listener(state);
+                    }));
+                };
+            },
+            deps: {
+                subscriptions: { token: CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN, optional: true },
+            },
+        },
+        provide({
+            provide: commandLineListTokens.resolvePageDeps,
+            multi: true,
+            useFactory: ({ actionRunner, actions }) => {
+                return function childAppRunActions() {
+                    return actionRunner.runActions(flatten(actions));
+                };
+            },
+            deps: {
+                actionRunner: ACTION_PAGE_RUNNER_TOKEN,
+                actions: CHILD_APP_INTERNAL_ACTION_TOKEN,
+            },
+        }),
+    ];
+};
+
+const getChildProviders = (appDi) => {
+    const logger = appDi.get(LOGGER_TOKEN);
+    return [
+        provide({
+            provide: LOGGER_TOKEN,
+            useValue: Object.assign((opts) => {
+                return logger('child-app').child(opts);
+            }, logger),
+        }),
+        provide({
+            provide: RENDER_SLOTS,
+            multi: true,
+            useValue: [],
+        }),
+        ...getChildProviders$1(appDi),
+    ];
+};
+
+const commonModuleStubs = [
+    DISPATCHER_TOKEN,
+    STORE_TOKEN,
+    CONTEXT_TOKEN,
+    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' });
+        },
+    };
+});
+
+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,
+            });
+            return null;
+        }
+    }
+    forEachChildDi(cb) {
+        this.cache.forEach((di) => {
+            cb(di);
+        });
+    }
+    resolveDi(config) {
+        const children = this.loader.get(config);
+        if (!children) {
+            return;
+        }
+        const di = new Container([
+            {
+                provide: CHILD_APP_INTERNAL_CONFIG_TOKEN,
+                useValue: config,
+            },
+            {
+                provide: IS_CHILD_APP_DI_TOKEN,
+                useValue: true,
+            },
+        ], this.appDi);
+        const { modules = [], providers = [], actions = [] } = children;
+        const childProviders = getChildProviders(this.appDi);
+        childProviders.forEach((provider) => {
+            di.register(provider);
+        });
+        const resolvedModules = walkOfModules(modules);
+        resolvedModules.forEach((mod) => {
+            const moduleParameters = getModuleParameters(mod);
+            moduleParameters.providers.forEach((provider) => {
+                di.register(provider);
+            });
+        });
+        providers.forEach((provider) => {
+            di.register(provider);
+        });
+        di.register({
+            provide: CHILD_APP_INTERNAL_ACTION_TOKEN,
+            multi: true,
+            useValue: actions,
+        });
+        const borrowTokens = di.get({ token: CHILD_APP_INTERNAL_ROOT_DI_BORROW_TOKEN, optional: true });
+        if (borrowTokens) {
+            flatten(borrowTokens).forEach((token) => {
+                di.borrowToken(this.appDi, token);
+            });
+        }
+        commonModuleStubs.forEach((stub) => {
+            if (!di.has(stub.provide)) {
+                di.register(stub);
+            }
+        });
+        return di;
+    }
+}
+
+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;
+        }
+        return new ChildContainer(singletonDi, this.appDi);
+    }
+}
+
+class CommandLineRunner {
+    constructor({ logger, rootCommandLineRunner, diManager, }) {
+        this.log = logger('child-app:commandlinerunner');
+        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: 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 = createEvent('child-app set preloaded');
+const initialState = {
+    preloaded: [],
+};
+const ChildAppStore = createReducer('child-app', initialState).on(setPreloaded, (_, preloaded) => {
+    return {
+        preloaded,
+    };
+});
+
+const RenderContext = createContext(null);
+
+const extendRender = ({ renderManager, }) => {
+    return (render) => {
+        return React.createElement(RenderContext.Provider, { value: renderManager }, 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,
+            },
+        };
+    }
+};
+const getModuleFederation = async (container, name = 'entry') => {
+    return container.get(name);
+};
+
+const sharedProviders = [
+    provide({
+        provide: COMBINE_REDUCERS,
+        multi: true,
+        useValue: ChildAppStore,
+    }),
+    provide({
+        provide: commandLineListTokens$1.init,
+        multi: true,
+        useValue: initModuleFederation,
+    }),
+    provide({
+        provide: CHILD_APP_GET_RESOLUTION_CONFIG_TOKEN,
+        useFactory: ({ configs }) => {
+            const mapping = flatten(configs !== null && configs !== void 0 ? configs : []).reduce((map, config) => {
+                return map.set(config.name, config);
+            }, new Map());
+            return (({ name, version, tag = 'latest' }) => {
+                var _a;
+                const fromMapping = mapping.get(name);
+                if (!fromMapping) {
+                    return null;
+                }
+                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,
+                };
+            });
+        },
+        deps: {
+            configs: { token: CHILD_APP_RESOLUTION_CONFIGS_TOKEN, optional: true },
+        },
+    }),
+    provide({
+        provide: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        useFactory: ({ envManager, rootBaseUrl, getResolutionConfig }) => {
+            const rawEnv = envManager.get('CHILD_APP_DEBUG');
+            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 = getResolutionConfig(req);
+                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: ENV_MANAGER_TOKEN,
+            rootBaseUrl: CHILD_APP_RESOLVE_BASE_URL_TOKEN,
+            getResolutionConfig: CHILD_APP_GET_RESOLUTION_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_RESOLVE_BASE_URL_TOKEN,
+        useFactory: ({ envManager }) => {
+            return envManager.get('CHILD_APP_EXTERNAL_URL');
+        },
+        deps: {
+            envManager: ENV_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
+        scope: Scope.SINGLETON,
+        useClass: SingletonDiManager,
+        deps: {
+            logger: LOGGER_TOKEN,
+            appDi: DI_TOKEN,
+            loader: CHILD_APP_LOADER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_DI_MANAGER_TOKEN,
+        useClass: DiManager,
+        deps: {
+            appDi: DI_TOKEN,
+            loader: CHILD_APP_LOADER_TOKEN,
+            singletonDiManager: CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
+        useClass: CommandLineRunner,
+        deps: {
+            logger: LOGGER_TOKEN,
+            rootCommandLineRunner: COMMAND_LINE_RUNNER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens$1.clear,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            return function childAppClear() {
+                return preloader.clearPreloaded();
+            };
+        },
+        deps: {
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: REGISTER_CLEAR_CACHE_TOKEN,
+        multi: true,
+        useFactory: ({ diManager }) => {
+            return (type) => {
+                diManager.forEachChildDi((di) => {
+                    var _a;
+                    const clearCache = di.get({ token: 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: REGISTER_CLEAR_CACHE_TOKEN,
+                        optional: true,
+                    })) !== null && _a !== void 0 ? _a : [];
+                    return Promise.all(registeredClearCache.map((clear) => clear(type)));
+                });
+            };
+        },
+        deps: {
+            diManager: CHILD_APP_SINGLETON_DI_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: EXTEND_RENDER,
+        multi: true,
+        useFactory: extendRender,
+        deps: {
+            renderManager: CHILD_APP_RENDER_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: 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', {
+            maxAge: 1000 * 60 * 60 * 24 * 5,
+            max: 20,
+        });
+        this.internalLoadCache = cache;
+        this.loader = new ServerLoader$1({
+            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, preloadExternalConfig, resolveFullConfig, }) {
+        this.shouldRunImmediately = false;
+        this.map = new Map();
+        this.preloadMap = new Map();
+        this.configHasBeenPreloaded = false;
+        this.loader = loader;
+        this.runner = runner;
+        this.stateManager = stateManager;
+        this.preloadExternalConfig = preloadExternalConfig;
+        this.resolveFullConfig = resolveFullConfig;
+    }
+    async preload(request) {
+        var _a;
+        if (!this.configHasBeenPreloaded) {
+            await ((_a = this.preloadExternalConfig) === null || _a === void 0 ? void 0 : _a.call(this));
+            this.configHasBeenPreloaded = true;
+        }
+        const config = this.resolveFullConfig(request);
+        const { key } = config;
+        if (this.map.has(key)) {
+            await this.map.get(key);
+            return;
+        }
+        const promise = this.loader
+            .load(config)
+            .then(() => {
+            if (this.shouldRunImmediately) {
+                return this.run('customer', config);
+            }
+        })
+            .catch(noop)
+            .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);
+        const { key } = config;
+        return this.map.has(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);
+    }
+    async clearPreloaded() {
+        const promises = [];
+        this.map.forEach((childAppPromise) => {
+            promises.push((async () => {
+                await this.run('clear', await childAppPromise);
+            })());
+        });
+        await Promise.all(promises);
+    }
+    getPreloadedList() {
+        return [...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);
+    }
+}
+
+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(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;
+    }
+}
+
+const LOAD_TIMEOUT = 500;
+const customRender = ({ renderManager, }) => {
+    return async (content) => {
+        let render = renderToString(content);
+        let timeouted = false;
+        await Promise.race([
+            new Promise((resolve) => setTimeout(resolve, LOAD_TIMEOUT)),
+            (async () => {
+                while ((await renderManager.flush()) && !timeouted) {
+                    render = renderToString(content);
+                }
+            })(),
+        ]);
+        timeouted = true;
+        return render;
+    };
+};
+class RenderManager {
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
+        this.hasRenderedSet = new Set();
+        this.loadingInProgress = new Map();
+        this.log = logger('child-app:render');
+        this.preloadManager = preloadManager;
+        this.diManager = diManager;
+        this.resolveFullConfig = resolveFullConfig;
+    }
+    getChildDi(request) {
+        const config = this.resolveFullConfig(request);
+        this.hasRenderedSet.add(config.key);
+        if (this.preloadManager.isPreloaded(request)) {
+            return [this.diManager.getChildDi(config), null];
+        }
+        this.log.warn({
+            message: 'Child-app has been used but not preloaded before React render',
+            request,
+        });
+        this.loadingInProgress.set(config.key, config);
+        const promiseDi = this.preloadManager.preload(request).then(() => {
+            return this.diManager.getChildDi(config);
+        });
+        return [null, promiseDi];
+    }
+    async flush() {
+        const promises = [];
+        for (const [_, request] of this.loadingInProgress.entries()) {
+            promises.push(this.preloadManager.preload(request));
+        }
+        this.loadingInProgress.clear();
+        if (promises.length) {
+            await Promise.all(promises);
+            return true;
+        }
+        return false;
+    }
+    clear() {
+        const preloadedList = this.preloadManager.getPreloadedList();
+        for (const request of preloadedList) {
+            const config = this.resolveFullConfig(request);
+            if (!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');
+    return preloadManager.getPreloadedList().map((requestConfig) => {
+        const config = resolveFullConfig(requestConfig);
+        const di = diManager.getChildDi(config);
+        if (!di) {
+            return [];
+        }
+        const slots = [
+            {
+                type: ResourceType.script,
+                slot: ResourceSlot.HEAD_CORE_SCRIPTS,
+                payload: config.client.entry,
+                attrs: {
+                    'data-critical': 'true',
+                },
+            },
+        ];
+        if (config.css) {
+            slots.push({
+                type: ResourceType.style,
+                slot: ResourceSlot.HEAD_CORE_STYLES,
+                payload: config.css.entry,
+                attrs: {
+                    'data-critical': 'true',
+                },
+            });
+        }
+        try {
+            const renderSlots = di.get({ token: RENDER_SLOTS, optional: true });
+            if (renderSlots) {
+                slots.push(...renderSlots);
+            }
+        }
+        catch (error) {
+            log.error({
+                event: 'get-slots-failed',
+                config: requestConfig,
+            });
+        }
+        return slots;
+    });
+};
+
+const serverProviders = [
+    provide({
+        provide: ENV_USED_TOKEN,
+        multi: true,
+        useValue: [
+            {
+                key: 'CHILD_APP_EXTERNAL_URL',
+                optional: true,
+                validator: combineValidators([isUrl, endsWith('/')]),
+            },
+        ],
+    }),
+    provide({
+        provide: CHILD_APP_LOADER_TOKEN,
+        useClass: ServerLoader,
+        scope: Scope.SINGLETON,
+        deps: {
+            logger: LOGGER_TOKEN,
+            createCache: CREATE_CACHE_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_STATE_MANAGER_TOKEN,
+        useClass: StateManager,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            resourcesRegistry: RESOURCES_REGISTRY,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        useClass: PreloadManager,
+        deps: {
+            loader: CHILD_APP_LOADER_TOKEN,
+            runner: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
+            stateManager: CHILD_APP_STATE_MANAGER_TOKEN,
+            preloadExternalConfig: { token: CHILD_APP_PRELOAD_EXTERNAL_CONFIG_TOKEN, optional: true },
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: RENDER_SLOTS,
+        multi: true,
+        useFactory: ({ stateManager, preloader, store }) => {
+            store.dispatch(setPreloaded(preloader.getPreloadedList()));
+            return {
+                type: ResourceType.inlineScript,
+                slot: ResourceSlot.BODY_END,
+                payload: `var childAppInitialState = '${safeDehydrate(stateManager.getState())}'`,
+            };
+        },
+        deps: {
+            stateManager: CHILD_APP_STATE_MANAGER_TOKEN,
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            store: STORE_TOKEN,
+        },
+    }),
+    provide({
+        provide: RENDER_SLOTS,
+        multi: true,
+        useFactory: registerChildAppRenderSlots,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+            preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CUSTOM_RENDER,
+        useFactory: customRender,
+        deps: {
+            renderManager: CHILD_APP_RENDER_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_RENDER_MANAGER_TOKEN,
+        useClass: RenderManager,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens$1.resolvePageDeps,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            return function childAppRunPreloaded() {
+                return preloader.runPreloaded();
+            };
+        },
+        deps: {
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens$1.clear,
+        multi: true,
+        useFactory: ({ renderManager }) => {
+            return function childAppRenderClear() {
+                renderManager.clear();
+            };
+        },
+        deps: {
+            renderManager: CHILD_APP_RENDER_MANAGER_TOKEN,
+        },
+    }),
+];
+
+const ChildApp = ({ name, version, tag, props }) => {
+    const renderManager = useContext(RenderContext);
+    const resolveExternalConfig = useDi(CHILD_APP_RESOLVE_CONFIG_TOKEN);
+    const logger = useDi(LOGGER_TOKEN);
+    const log = logger('child-app:render');
+    const [maybeDi, promiseDi] = useMemo(() => {
+        return renderManager.getChildDi(resolveExternalConfig({ name, version, tag }));
+    }, [name, version, tag, renderManager, resolveExternalConfig]);
+    const [di, setDi] = useState(maybeDi);
+    useEffect(() => {
+        if (!di && promiseDi) {
+            // any errors with loading child-app should be handled in some other place
+            promiseDi.then(setDi).catch(noop);
+        }
+    }, [di, promiseDi]);
+    if (!di) {
+        log.error({
+            event: 'not-found',
+            name,
+            version,
+            tag,
+            message: 'child-app was not initialized',
+        });
+        return null;
+    }
+    try {
+        const Cmp = di.get({ token: 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 createElement(Cmp, {
+            di,
+            props,
+        });
+    }
+    catch (error) {
+        log.error({
+            event: 'get-render',
+            message: 'Cannot get render token from child-app',
+            error,
+            name,
+            version,
+            tag,
+        });
+        return null;
+    }
+};
+
+let ChildAppModule = class ChildAppModule {
+};
+ChildAppModule = __decorate([
+    Module({
+        imports: [],
+        providers: [...sharedProviders, ...serverProviders],
+    })
+], ChildAppModule);
+
+export { ChildApp, ChildAppModule };