@tramvai/module-child-app 1.46.5

package/lib/server.browser.js

@@ -0,0 +1,793 @@
+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_COMMON_INITIAL_STATE_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 } from '@tramvai/tokens-common';
+import { RENDER_SLOTS, EXTEND_RENDER } from '@tramvai/tokens-render';
+import { Subscription, createEvent, createReducer } from '@tramvai/state';
+import React, { createContext, useContext, useMemo, useState, useEffect, createElement } from 'react';
+import { loadModule } from '@tinkoff/module-loader-client';
+import noop from '@tinkoff/utils/function/noop';
+import { useDi } from '@tramvai/react';
+
+const getChildProviders$1 = (appDi) => {
+    const context = appDi.get(CONTEXT_TOKEN);
+    return [
+        {
+            provide: commandLineListTokens.customerStart,
+            multi: true,
+            useFactory: ({ subscriptions, }) => {
+                return async function resolveRootStateForChild() {
+                    if (!subscriptions) {
+                        return;
+                    }
+                    const state = context.getState();
+                    return Promise.all(subscriptions.map((sub) => {
+                        const subscription = new Subscription(sub.stores.map(context.getStore));
+                        subscription.setOnStateChange(() => {
+                            sub.listener(context.getState());
+                        });
+                        subscription.trySubscribe();
+                        return sub.listener(state);
+                    }));
+                };
+            },
+            deps: {
+                subscriptions: { token: CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN, optional: true },
+            },
+        },
+        provide({
+            provide: commandLineListTokens.clear,
+            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;
+    }
+}
+
+const getModuleFromGlobal = (entry) => {
+    return window[`child-app__${entry}`];
+};
+class BrowserLoader extends Loader {
+    constructor({ logger }) {
+        super();
+        this.initializedMap = new WeakMap();
+        this.log = logger('child-app:loader');
+    }
+    async load(config) {
+        const moduleName = config.name;
+        const childApp = await this.get(config);
+        if (childApp) {
+            this.log.debug({
+                event: 'load-cache',
+                moduleName,
+            });
+            return childApp;
+        }
+        let container = getModuleFromGlobal(config.client.entry);
+        if (!container) {
+            this.log.debug({
+                event: 'load-fetch',
+                moduleName,
+            });
+            await loadModule(config.client.entry);
+            container = getModuleFromGlobal(config.client.entry);
+            if (container) {
+                this.log.debug({
+                    event: 'load-success',
+                    moduleName,
+                });
+                await this.init(config);
+                return this.get(config);
+            }
+        }
+        this.log.error({
+            event: 'load-failed',
+            moduleName,
+        });
+        return Promise.reject(new Error(`Error resolving module ${moduleName}`));
+    }
+    async init(config) {
+        const container = getModuleFromGlobal(config.client.entry);
+        if (container) {
+            await initModuleFederation(container);
+            const factory = (await getModuleFederation(container, 'entry'));
+            const entry = factory();
+            this.initializedMap.set(container, entry);
+        }
+    }
+    get(config) {
+        const container = getModuleFromGlobal(config.client.entry);
+        const entry = container && this.initializedMap.get(container);
+        return entry && this.resolve(entry);
+    }
+}
+
+class PreloadManager {
+    constructor({ loader, runner, resolveExternalConfig, store, }) {
+        this.pageHasLoaded = false;
+        this.map = new Map();
+        this.serverPreloaded = new Map();
+        this.preloadMap = new Map();
+        this.loader = loader;
+        this.runner = runner;
+        this.resolveExternalConfig = resolveExternalConfig;
+        const { preloaded } = store.getState(ChildAppStore);
+        preloaded.forEach((request) => {
+            const config = this.resolveExternalConfig(request);
+            this.serverPreloaded.set(config.key, config);
+        });
+    }
+    async preload(request) {
+        const config = this.resolveExternalConfig(request);
+        const { key } = config;
+        this.preloadMap.set(key, config);
+        if (!this.map.has(key)) {
+            if (this.pageHasLoaded) {
+                const promise = (async () => {
+                    try {
+                        await this.loader.load(config);
+                        await this.run('customer', config);
+                        await this.run('clear', config);
+                    }
+                    catch (error) { }
+                    return config;
+                })();
+                this.map.set(key, promise);
+            }
+        }
+    }
+    isPreloaded(request) {
+        const config = this.resolveExternalConfig(request);
+        const { key } = config;
+        return this.map.has(key) || this.serverPreloaded.has(key);
+    }
+    async runPreloaded() {
+        const promises = [];
+        if (this.pageHasLoaded) {
+            this.map.forEach((childAppPromise) => {
+                promises.push((async () => {
+                    await this.run('spa', await childAppPromise);
+                })());
+            });
+        }
+        else {
+            this.serverPreloaded.forEach((config) => {
+                promises.push((async () => {
+                    await this.loader.init(config);
+                    await this.run('customer', config);
+                })());
+            });
+        }
+        await Promise.all(promises);
+    }
+    async clearPreloaded() {
+        this.pageHasLoaded = true;
+        const promises = [];
+        this.preloadMap.forEach((config) => {
+            promises.push((async () => {
+                if (this.serverPreloaded.has(config.key)) {
+                    promises.push(this.run('clear', config));
+                }
+                else {
+                    const promise = this.loader
+                        .load(config)
+                        .catch(noop)
+                        .then(() => config);
+                    this.map.set(config.key, promise);
+                    await promise;
+                    await this.run('customer', config);
+                    await this.run('clear', config);
+                }
+            })());
+        });
+        this.serverPreloaded.clear();
+        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('client', status, config);
+    }
+}
+
+class RenderManager {
+    constructor({ logger, preloadManager, diManager, resolveExternalConfig, }) {
+        this.hasRenderedSet = new Set();
+        this.loadingInProgress = new Map();
+        this.log = logger('child-app:render');
+        this.preloadManager = preloadManager;
+        this.diManager = diManager;
+        this.resolveExternalConfig = resolveExternalConfig;
+    }
+    getChildDi(request) {
+        const config = this.resolveExternalConfig(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() {
+        return false;
+    }
+    clear() { }
+}
+
+const browserProviders = [
+    provide({
+        provide: CHILD_APP_LOADER_TOKEN,
+        useClass: BrowserLoader,
+        scope: Scope.SINGLETON,
+        deps: {
+            logger: LOGGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        useClass: PreloadManager,
+        deps: {
+            loader: CHILD_APP_LOADER_TOKEN,
+            runner: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
+            resolveExternalConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+            store: STORE_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_COMMON_INITIAL_STATE_TOKEN,
+        useFactory: () => JSON.parse(window.childAppInitialState || '{}'),
+    }),
+    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,
+            resolveExternalConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens$1.resolvePageDeps,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            let hasCalled = false;
+            return function childAppRunPreloaded() {
+                if (hasCalled)
+                    return;
+                hasCalled = true;
+                return preloader.runPreloaded();
+            };
+        },
+        deps: {
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens$1.spaTransition,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            return function childAppRunPreloaded() {
+                return preloader.runPreloaded();
+            };
+        },
+        deps: {
+            preloader: CHILD_APP_PRELOAD_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, ...browserProviders],
+    })
+], ChildAppModule);
+
+export { ChildApp, ChildAppModule };