@tramvai/module-render 2.70.0 → 2.72.0

package/lib/server.es.js

@@ -1,869 +1,28 @@
 import { __decorate } from 'tslib';
-import { useMemo, createElement } from 'react';
+import { createElement } from 'react';
 import { renderToString } from 'react-dom/server';
 import { Module, provide, commandLineListTokens, DI_TOKEN } from '@tramvai/core';
-import { COMBINE_REDUCERS, CREATE_CACHE_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, RESPONSE_MANAGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
+import { CREATE_CACHE_TOKEN, LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, RESPONSE_MANAGER_TOKEN, CONTEXT_TOKEN } from '@tramvai/tokens-common';
 import { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
 import { ClientHintsModule, USER_AGENT_TOKEN } from '@tramvai/module-client-hints';
-import { ResourceType, ResourceSlot, DEFAULT_LAYOUT_COMPONENT, LAYOUT_OPTIONS, DEFAULT_FOOTER_COMPONENT, DEFAULT_HEADER_COMPONENT, DEFAULT_ERROR_BOUNDARY_COMPONENT, TRAMVAI_RENDER_MODE, RESOURCES_REGISTRY, RESOURCE_INLINE_OPTIONS, RENDER_SLOTS, POLYFILL_CONDITION, HTML_ATTRS, MODERN_SATISFIES_TOKEN, RENDER_FLOW_AFTER_TOKEN, CUSTOM_RENDER, EXTEND_RENDER, REACT_SERVER_RENDER_MODE } from '@tramvai/tokens-render';
+import { RESOURCES_REGISTRY, RESOURCE_INLINE_OPTIONS, RENDER_SLOTS, POLYFILL_CONDITION, HTML_ATTRS, MODERN_SATISFIES_TOKEN, RENDER_FLOW_AFTER_TOKEN, CUSTOM_RENDER, EXTEND_RENDER, REACT_SERVER_RENDER_MODE, ResourceType } from '@tramvai/tokens-render';
 export * from '@tramvai/tokens-render';
-import { createToken, Scope } from '@tinkoff/dippy';
+import { Scope } from '@tinkoff/dippy';
 import { WEB_FASTIFY_APP_BEFORE_ERROR_TOKEN } from '@tramvai/tokens-server-private';
-import { useDi, ERROR_BOUNDARY_TOKEN, ERROR_BOUNDARY_FALLBACK_COMPONENT_TOKEN, UniversalErrorBoundary, DIContext, ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN } from '@tramvai/react';
-import { resolve, isAbsoluteUrl as isAbsoluteUrl$1, parse } from '@tinkoff/url';
+import { ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN } from '@tramvai/react';
+import { parse } from '@tinkoff/url';
 import { satisfies } from '@tinkoff/user-agent';
-import isUndefined from '@tinkoff/utils/is/undefined';
-import isEmpty from '@tinkoff/utils/is/empty';
-import fetch from 'node-fetch';
-import startsWith from '@tinkoff/utils/string/startsWith';
-import toArray from '@tinkoff/utils/array/toArray';
-import flatten from '@tinkoff/utils/array/flatten';
-import { buildPage, staticRender, dynamicRender } from '@tinkoff/htmlpagebuilder';
-import { safeStringify } from '@tramvai/safe-strings';
-import { ChunkExtractor } from '@loadable/server';
-import has from '@tinkoff/utils/object/has';
-import last from '@tinkoff/utils/array/last';
-import { isFileSystemPageComponent, fileSystemPageToWebpackChunkName } from '@tramvai/experiments';
-import uniq from '@tinkoff/utils/array/uniq';
-import * as path from 'path';
-import each from '@tinkoff/utils/array/each';
-import path$1 from '@tinkoff/utils/object/path';
-import { o as onload } from './server_inline.inline.es.js';
-import { Writable } from 'stream';
-import { jsx } from 'react/jsx-runtime';
-import { createEvent, createReducer, useStore, Provider } from '@tramvai/state';
-import { useUrl, usePageService } from '@tramvai/module-router';
-import { composeLayoutOptions, createLayout } from '@tinkoff/layout-factory';
-
-const thirtySeconds = 1000 * 30;
-const getFileContentLength = async (url) => {
-    const info = await fetch(url, { method: 'HEAD', timeout: thirtySeconds });
-    return info.headers.get('content-length');
-};
-const getFile = async (url) => {
-    const fileResponse = await fetch(url, { timeout: thirtySeconds });
-    if (fileResponse.ok) {
-        const file = await fileResponse.text();
-        return file;
-    }
-    return undefined;
-};
-
-const URL_OCCURRENCES_RE = /(url\((['"]?))(.*?)(\2\))/gi;
-const isAbsoluteUrl = (resourceUrl) => ['http://', 'https://', '//'].some((prefix) => startsWith(prefix, resourceUrl));
-const toHttpsUrl = (resourceUrl) => {
-    if (resourceUrl.indexOf('//localhost') !== -1) {
-        return resourceUrl;
-    }
-    if (startsWith('http://', resourceUrl)) {
-        return resourceUrl.replace('http://', 'https://');
-    }
-    if (startsWith('//', resourceUrl)) {
-        return resourceUrl.replace('//', 'https://');
-    }
-    return resourceUrl;
-};
-const urlReplacerCreator = (resourceUrl) => (str, leftGroup, _, extractedUrl, rightGroup) => {
-    return isAbsoluteUrl(extractedUrl)
-        ? str
-        : `${leftGroup}${resolve(toHttpsUrl(resourceUrl), extractedUrl)}${rightGroup}`;
-};
-const processFile = (resource, file) => {
-    if (resource.type === ResourceType.style) {
-        return file.replace(URL_OCCURRENCES_RE, urlReplacerCreator(resource.payload));
-    }
-    return file;
-};
-
-const INTERNAL_CACHE_SIZE = 50;
-const ASSETS_PREFIX = process.env.NODE_ENV === 'development' &&
-    (process.env.ASSETS_PREFIX === 'static' || !process.env.ASSETS_PREFIX)
-    ? `http://localhost:${process.env.PORT_STATIC}/dist/`
-    : process.env.ASSETS_PREFIX;
-const getInlineType = (type) => {
-    switch (type) {
-        case ResourceType.style:
-            return ResourceType.inlineStyle;
-        case ResourceType.script:
-            return ResourceType.inlineScript;
-        default:
-            return type;
-    }
-};
-const getResourceUrl = (resource) => {
-    if (isEmpty(resource.payload) || !isAbsoluteUrl$1(resource.payload)) {
-        return undefined;
-    }
-    return resource.payload.startsWith('//')
-        ? `https://${resource.payload.substr(2)}`
-        : resource.payload;
-};
-class ResourcesInliner {
-    constructor({ resourcesRegistryCache, resourceInlineThreshold, logger }) {
-        this.internalFilesCache = new Map();
-        this.runningRequests = new Set();
-        this.scheduleFileLoad = async (resource, resourceInlineThreshold) => {
-            const url = getResourceUrl(resource);
-            const requestKey = `file${url}`;
-            const filesCache = this.getFilesCache(url);
-            const result = filesCache.get(url);
-            if (result) {
-                return result;
-            }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(url);
-                try {
-                    const file = await getFile(url);
-                    if (file === undefined) {
-                        this.resourcesRegistryCache.disabledUrlsCache.set(url, true);
-                        return;
-                    }
-                    const size = file.length;
-                    if (size < resourceInlineThreshold) {
-                        filesCache.set(url, processFile(resource, file));
-                    }
-                    this.resourcesRegistryCache.sizeCache.set(url, size);
-                }
-                catch (error) {
-                    this.log.warn({
-                        event: 'file-load-failed',
-                        url,
-                        error,
-                    });
-                }
-                finally {
-                    this.runningRequests.delete(requestKey);
-                }
-            }
-        };
-        this.scheduleFileSizeLoad = async (resource, resourceInlineThreshold) => {
-            const url = getResourceUrl(resource);
-            const requestKey = `size${url}`;
-            const result = this.resourcesRegistryCache.sizeCache.get(url);
-            if (result) {
-                return result;
-            }
-            if (!this.runningRequests.has(requestKey)) {
-                this.runningRequests.add(requestKey);
-                try {
-                    const contentLength = await getFileContentLength(url);
-                    const size = isUndefined(contentLength) ? 0 : +contentLength;
-                    if (size) {
-                        this.resourcesRegistryCache.sizeCache.set(url, size);
-                    }
-                    if (size < resourceInlineThreshold) {
-                        this.scheduleFileLoad(resource, resourceInlineThreshold);
-                    }
-                }
-                catch (error) {
-                    this.log.warn({
-                        event: 'file-content-length-load-failed',
-                        url,
-                        error,
-                    });
-                }
-                finally {
-                    this.runningRequests.delete(requestKey);
-                }
-            }
-        };
-        this.resourcesRegistryCache = resourcesRegistryCache;
-        this.resourceInlineThreshold = resourceInlineThreshold;
-        this.log = logger('resources-inliner');
-    }
-    getFilesCache(url) {
-        if (url.startsWith(ASSETS_PREFIX)) {
-            // internal resources are resources generated by the current app itself
-            // these kind of resources are pretty static and won't be changed while app is running
-            // so we can cache it with bare Map and do not care about how to cleanup cache from outdated entries
-            return this.internalFilesCache;
-        }
-        return this.resourcesRegistryCache.filesCache;
-    }
-    // check that resource's preload-link should be added to render
-    shouldAddResource(resource) {
-        if (resource.type !== ResourceType.preloadLink) {
-            // only checking preload-links
-            return true;
-        }
-        const url = getResourceUrl(resource);
-        if (isUndefined(url)) {
-            // if url is undefined that file is not in cache
-            return true;
-        }
-        // if file is residing in cache that means it will be inlined in page render
-        // therefore no need to have preload-link for the inlined resource
-        return !this.getFilesCache(url).has(url);
-    }
-    // method for check is passed resource should be inlined in HTML-page
-    shouldInline(resource) {
-        var _a;
-        if (!(((_a = this.resourceInlineThreshold) === null || _a === void 0 ? void 0 : _a.types) || []).includes(resource.type)) {
-            return false;
-        }
-        const resourceInlineThreshold = this.resourceInlineThreshold.threshold;
-        if (isUndefined(resourceInlineThreshold)) {
-            return false;
-        }
-        const url = getResourceUrl(resource);
-        if (isUndefined(url) || this.resourcesRegistryCache.disabledUrlsCache.has(url)) {
-            return false;
-        }
-        const filesCache = this.getFilesCache(url);
-        if (filesCache.has(url)) {
-            return true;
-        }
-        if (filesCache === this.internalFilesCache &&
-            this.internalFilesCache.size >= INTERNAL_CACHE_SIZE) {
-            // if we've exceeded limits for the internal resources cache ignore any new entries
-            return false;
-        }
-        if (!this.resourcesRegistryCache.sizeCache.has(url)) {
-            this.scheduleFileSizeLoad(resource, resourceInlineThreshold);
-            return false;
-        }
-        const size = this.resourcesRegistryCache.sizeCache.get(url);
-        if (size > resourceInlineThreshold) {
-            return false;
-        }
-        this.scheduleFileLoad(resource, resourceInlineThreshold);
-        return false;
-    }
-    inlineResource(resource) {
-        const url = getResourceUrl(resource);
-        if (isUndefined(url)) {
-            // usually, it should not happen but anyway check it for safety
-            return [resource];
-        }
-        const text = this.getFilesCache(url).get(url);
-        if (isEmpty(text)) {
-            return [resource];
-        }
-        const result = [];
-        if (process.env.NODE_ENV === 'development') {
-            // html comment for debugging inlining in dev mode
-            result.push({
-                slot: resource.slot,
-                type: ResourceType.asIs,
-                payload: `<!-- Inlined file ${url} -->`,
-            });
-        }
-        result.push({
-            ...resource,
-            type: getInlineType(resource.type),
-            payload: text,
-        });
-        if (resource.type === ResourceType.style) {
-            // If we don't add data-href then extract-css-chunks-webpack-plugin
-            // will add link to resources to the html head (https://github.com/faceyspacey/extract-css-chunks-webpack-plugin/blob/master/src/index.js#L346)
-            // wherein link in case of css files plugin will look for a link tag, but we add a style tag
-            // so we can't use tag from above and have to generate new one
-            result.push({
-                slot: resource.slot,
-                type: ResourceType.style,
-                payload: null,
-                attrs: {
-                    'data-href': resource.payload,
-                },
-            });
-        }
-        return result;
-    }
-}
-
-/**
- * @description
- * Инлайнер ресурсов - используется на сервере для регистрации файлов, которые должны быть вставлены
- * в итоговую html-страницу в виде ссылки на файл или заинлайнеными полностью
- */
-const RESOURCE_INLINER = createToken('resourceInliner');
-/**
- * @description
- * Кэш загруженных ресурсов.
- */
-const RESOURCES_REGISTRY_CACHE = createToken('resourcesRegistryCache');
-
-class ResourcesRegistry {
-    constructor({ resourceInliner }) {
-        this.resources = new Set();
-        this.resourceInliner = resourceInliner;
-    }
-    register(resourceOrResources) {
-        toArray(resourceOrResources).forEach((resource) => {
-            this.resources.add(resource);
-        });
-    }
-    getPageResources() {
-        return Array.from(this.resources.values())
-            .reduce((acc, resource) => {
-            if (this.resourceInliner.shouldInline(resource)) {
-                Array.prototype.push.apply(acc, this.resourceInliner.inlineResource(resource));
-            }
-            else {
-                acc.push(resource);
-            }
-            return acc;
-        }, [])
-            .filter((resource) => this.resourceInliner.shouldAddResource(resource));
-    }
-}
-
-const PRELOAD_JS = '__preloadJS';
-
-const isJs = (file) => /\.js$/.test(file) && !/\.hot-update\.js$/.test(file);
-const isCss = (file) => /\.css$/.test(file);
-const getFilesByType = (files) => {
-    const scripts = files.filter(isJs);
-    const styles = files.filter(isCss);
-    return {
-        scripts,
-        styles,
-    };
-};
-const flushFiles = (chunks, webpackStats, { ignoreDependencies = false, } = {}) => {
-    // при использовании namedChunkGroups во все entry-файлы как зависимость попадает runtimeChunk
-    // что при повторных вызовах flushChunks вызовет дублирование подключения manifest.js
-    // из-за чего приложение может запускаться несколько раз
-    // без поля namedChunkGroups flushChunks вернет только сами ассеты для чанков, без зависимостей
-    const { assetsByChunkName, namedChunkGroups } = webpackStats;
-    const resolvedChunks = [];
-    for (const chunk of chunks) {
-        if (!ignoreDependencies && (namedChunkGroups === null || namedChunkGroups === void 0 ? void 0 : namedChunkGroups[chunk])) {
-            resolvedChunks.push(...namedChunkGroups[chunk].chunks);
-        }
-        else {
-            resolvedChunks.push(chunk);
-        }
-    }
-    const files = flatten(uniq(resolvedChunks).map((chunk) => assetsByChunkName[chunk]));
-    return getFilesByType(files);
-};
-
-const requireFunc = 
-// @ts-ignore
-typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
-
-let appConfig;
-try {
-    appConfig = require('@tramvai/cli/lib/external/config').appConfig;
-}
-catch (e) { }
-let fetchStats = async () => {
-    throw new Error(`Unknown environment`);
-};
-if (process.env.NODE_ENV === 'development') {
-    fetchStats = async () => {
-        const { modern: configModern, staticHost, staticPort, output } = appConfig;
-        const getUrl = (filename) => `http://${staticHost}:${staticPort}/${output.client}/${filename}`;
-        const request = await fetch(getUrl(configModern ? 'stats.modern.json' : 'stats.json'));
-        const stats = await request.json();
-        // static - популярная заглушка в env.development.js файлах, надо игнорировать, как было раньше
-        const hasAssetsPrefix = process.env.ASSETS_PREFIX && process.env.ASSETS_PREFIX !== 'static';
-        const publicPath = hasAssetsPrefix ? process.env.ASSETS_PREFIX : stats.publicPath;
-        return {
-            ...stats,
-            publicPath,
-        };
-    };
-}
-if (process.env.NODE_ENV === 'test') {
-    fetchStats = () => {
-        // mock for unit-testing as there is no real static return something just to make server render work
-        return Promise.resolve({ publicPath: 'http://localhost:4000/', assetsByChunkName: {} });
-    };
-}
-if (process.env.NODE_ENV === 'production') {
-    const SEARCH_PATHS = [process.cwd(), __dirname];
-    const webpackStats = (fileName) => {
-        let stats;
-        for (const dir of SEARCH_PATHS) {
-            try {
-                const statsPath = path.resolve(dir, fileName);
-                stats = requireFunc(statsPath);
-                break;
-            }
-            catch (e) {
-                // ignore errors as this function is used to load stats for several optional destinations
-                // and these destinations may not have stats file
-            }
-        }
-        if (!stats) {
-            return;
-        }
-        if (!process.env.ASSETS_PREFIX) {
-            if (process.env.STATIC_PREFIX) {
-                throw new Error('Required env variable "ASSETS_PREFIX" is not set. Instead of using "STATIC_PREFIX" env please define "ASSETS_PREFIX: STATIC_PREFIX + /compiled"');
-            }
-            throw new Error('Required env variable "ASSETS_PREFIX" is not set');
-        }
-        return {
-            ...stats,
-            publicPath: process.env.ASSETS_PREFIX,
-        };
-    };
-    const statsLegacy = webpackStats('stats.json');
-    const statsModern = webpackStats('stats.modern.json') || statsLegacy;
-    if (!statsLegacy) {
-        throw new Error(`Cannot find stats.json.
-  It should be placed in one of the next places:
-    ${SEARCH_PATHS.join('\n\t')}
-  In case it happens on deployment:
-    - In case you are using two independent jobs for building app
-      - Either do not split build command by two independent jobs and use one common job with "tramvai build" command without --buildType
-      - Or copy stats.json (and stats.modern.json if present) file from client build output to server output by yourself in your CI
-    - Otherwise report issue to tramvai team
-  In case it happens locally:
-    - prefer to use command "tramvai start-prod" to test prod-build locally
-    - copy stats.json next to built server.js file
-`);
-    }
-    fetchStats = (modern) => {
-        const stats = modern ? statsModern : statsLegacy;
-        return Promise.resolve(stats);
-    };
-}
-const fetchWebpackStats = async ({ modern, } = {}) => {
-    return fetchStats(modern);
-};
-
-const bundleResource = async ({ bundle, modern, extractor, pageComponent, }) => {
-    // for file-system pages preload page chunk against bundle chunk
-    const chunkNameFromBundle = isFileSystemPageComponent(pageComponent)
-        ? fileSystemPageToWebpackChunkName(pageComponent)
-        : last(bundle.split('/'));
-    const webpackStats = await fetchWebpackStats({ modern });
-    const { publicPath, assetsByChunkName } = webpackStats;
-    const bundles = has('common-chunk', assetsByChunkName)
-        ? ['common-chunk', chunkNameFromBundle]
-        : [chunkNameFromBundle];
-    const lazyChunks = extractor.getMainAssets().map((entry) => entry.chunk);
-    const { scripts: baseScripts } = flushFiles(['vendor'], webpackStats, {
-        ignoreDependencies: true,
-    });
-    const { scripts, styles } = flushFiles([...bundles, ...lazyChunks, 'platform'], webpackStats);
-    const genHref = (href) => `${publicPath}${href}`;
-    const result = [];
-    if (process.env.NODE_ENV === 'production' ||
-        (process.env.ASSETS_PREFIX && process.env.ASSETS_PREFIX !== 'static')) {
-        result.push({
-            type: ResourceType.inlineScript,
-            slot: ResourceSlot.HEAD_CORE_SCRIPTS,
-            payload: `window.ap = ${`"${process.env.ASSETS_PREFIX}"`};`,
-        });
-    }
-    styles.map((style) => result.push({
-        type: ResourceType.style,
-        slot: ResourceSlot.HEAD_CORE_STYLES,
-        payload: genHref(style),
-        attrs: {
-            'data-critical': 'true',
-            onload: `${PRELOAD_JS}()`,
-        },
-    }));
-    baseScripts.map((script) => result.push({
-        type: ResourceType.script,
-        slot: ResourceSlot.HEAD_CORE_SCRIPTS,
-        payload: genHref(script),
-        attrs: {
-            'data-critical': 'true',
-        },
-    }));
-    scripts.map((script) => result.push({
-        type: ResourceType.script,
-        slot: ResourceSlot.HEAD_CORE_SCRIPTS,
-        payload: genHref(script),
-        attrs: {
-            'data-critical': 'true',
-        },
-    }));
-    return result;
-};
-
-const polyfillResources = async ({ condition, modern, }) => {
-    const webpackStats = await fetchWebpackStats({ modern });
-    const { publicPath } = webpackStats;
-    // получает файл полифилла из stats.json\stats.modern.json.
-    // В зависимости от версии браузера будет использован полифилл из legacy или modern сборки,
-    // т.к. полифиллы для них могут отличаться на основании преобразований `@babel/preset-env`
-    const { scripts: polyfillScripts } = flushFiles(['polyfill'], webpackStats, {
-        ignoreDependencies: true,
-    });
-    const genHref = (href) => `${publicPath}${href}`;
-    const result = [];
-    polyfillScripts.forEach((script) => {
-        const href = genHref(script);
-        result.push({
-            type: ResourceType.inlineScript,
-            slot: ResourceSlot.HEAD_POLYFILLS,
-            payload: `(function (){
-  var con;
-  try {
-    con = ${condition};
-  } catch (e) {
-    con = true;
-  }
-  if (con) { document.write('<script defer="defer" charset="utf-8" data-critical="true" crossorigin="anonymous" src="${href}"><\\/script>')}
-})()`,
-        });
-    });
-    return result;
-};
-
-const addPreloadForCriticalJS = (pageResources) => {
-    const jsUrls = [];
-    each((res) => {
-        if (res.type === 'script' && path$1(['attrs', 'data-critical'], res)) {
-            jsUrls.push(res.payload);
-        }
-    }, pageResources);
-    return {
-        type: ResourceType.inlineScript,
-        slot: ResourceSlot.HEAD_PERFORMANCE,
-        payload: `window.${PRELOAD_JS}=(${onload})([${jsUrls.map((url) => `"${url}"`).join(',')}])`,
-    };
-};
-
-const formatAttributes = (htmlAttrs, target) => {
-    if (!htmlAttrs) {
-        return '';
-    }
-    const targetAttrs = htmlAttrs.filter((item) => item.target === target);
-    const collectedAttrs = targetAttrs.reduce((acc, item) => ({ ...acc, ...item.attrs }), {});
-    const attrsString = Object.keys(collectedAttrs).reduce((acc, name) => {
-        if (collectedAttrs[name] === true) {
-            return `${acc} ${name}`;
-        }
-        return `${acc} ${name}="${collectedAttrs[name]}"`;
-    }, '');
-    return attrsString.trim();
-};
-
-/* eslint-disable sort-class-members/sort-class-members */
-const mapResourcesToSlots = (resources) => resources.reduce((acc, resource) => {
-    const { slot } = resource;
-    if (Array.isArray(acc[slot])) {
-        acc[slot].push(resource);
-    }
-    else {
-        acc[slot] = [resource];
-    }
-    return acc;
-}, {});
-class PageBuilder {
-    constructor({ renderSlots, pageService, resourcesRegistry, context, reactRender, htmlPageSchema, polyfillCondition, htmlAttrs, modern, renderFlowAfter, logger, }) {
-        this.htmlAttrs = htmlAttrs;
-        this.renderSlots = flatten(renderSlots || []);
-        this.pageService = pageService;
-        this.context = context;
-        this.resourcesRegistry = resourcesRegistry;
-        this.reactRender = reactRender;
-        this.htmlPageSchema = htmlPageSchema;
-        this.polyfillCondition = polyfillCondition;
-        this.modern = modern;
-        this.renderFlowAfter = renderFlowAfter || [];
-        this.log = logger('page-builder');
-    }
-    async flow() {
-        const stats = await fetchWebpackStats({ modern: this.modern });
-        const extractor = new ChunkExtractor({ stats, entrypoints: [] });
-        // first we render the application, because we need to extract information about the data used by the components
-        await this.renderApp(extractor);
-        await Promise.all(this.renderFlowAfter.map((callback) => callback().catch((error) => {
-            this.log.warn({ event: 'render-flow-after-error', callback, error });
-        })));
-        this.dehydrateState();
-        // load information and dependency for the current bundle and page
-        await this.fetchChunksInfo(extractor);
-        this.preloadBlock();
-        return this.generateHtml();
-    }
-    dehydrateState() {
-        this.resourcesRegistry.register({
-            type: ResourceType.asIs,
-            slot: ResourceSlot.BODY_END,
-            // String much better than big object, source https://v8.dev/blog/cost-of-javascript-2019#json
-            payload: `<script id="__TRAMVAI_STATE__" type="application/json">${safeStringify(this.context.dehydrate().dispatcher)}</script>`,
-        });
-    }
-    async fetchChunksInfo(extractor) {
-        const { modern } = this;
-        const { bundle, pageComponent } = this.pageService.getConfig();
-        this.resourcesRegistry.register(await bundleResource({ bundle, modern, extractor, pageComponent }));
-        this.resourcesRegistry.register(await polyfillResources({
-            condition: this.polyfillCondition,
-            modern,
-        }));
-    }
-    preloadBlock() {
-        const preloadResources = addPreloadForCriticalJS(this.resourcesRegistry.getPageResources());
-        this.resourcesRegistry.register(preloadResources);
-    }
-    generateHtml() {
-        const resultSlotHandlers = mapResourcesToSlots([
-            ...this.renderSlots,
-            ...this.resourcesRegistry.getPageResources(),
-        ]);
-        return buildPage({
-            slotHandlers: resultSlotHandlers,
-            description: this.htmlPageSchema,
-        });
-    }
-    async renderApp(extractor) {
-        const html = await this.reactRender.render(extractor);
-        this.renderSlots = this.renderSlots.concat({
-            type: ResourceType.asIs,
-            slot: ResourceSlot.REACT_RENDER,
-            payload: `<div ${formatAttributes(this.htmlAttrs, 'app')}>${html}</div>`,
-        });
-    }
-}
-/* eslint-enable sort-class-members/sort-class-members */
-
-const { REACT_RENDER, HEAD_CORE_SCRIPTS, HEAD_DYNAMIC_SCRIPTS, HEAD_META, HEAD_POLYFILLS, HEAD_CORE_STYLES, HEAD_PERFORMANCE, HEAD_ANALYTICS, BODY_START, BODY_END, HEAD_ICONS, BODY_TAIL_ANALYTICS, BODY_TAIL, } = ResourceSlot;
-const htmlPageSchemaFactory = ({ htmlAttrs, }) => {
-    return [
-        staticRender('<!DOCTYPE html>'),
-        staticRender(`<html ${formatAttributes(htmlAttrs, 'html')}>`),
-        staticRender('<head>'),
-        staticRender('<meta charset="UTF-8">'),
-        dynamicRender(HEAD_META),
-        dynamicRender(HEAD_PERFORMANCE),
-        dynamicRender(HEAD_CORE_STYLES),
-        dynamicRender(HEAD_POLYFILLS),
-        dynamicRender(HEAD_DYNAMIC_SCRIPTS),
-        dynamicRender(HEAD_CORE_SCRIPTS),
-        dynamicRender(HEAD_ANALYTICS),
-        dynamicRender(HEAD_ICONS),
-        staticRender('</head>'),
-        staticRender(`<body ${formatAttributes(htmlAttrs, 'body')}>`),
-        dynamicRender(BODY_START),
-        // react app
-        dynamicRender(REACT_RENDER),
-        dynamicRender(BODY_END),
-        dynamicRender(BODY_TAIL_ANALYTICS),
-        dynamicRender(BODY_TAIL),
-        staticRender('</body>'),
-        staticRender('</html>'),
-    ];
-};
-
-function serializeError(error) {
-    return {
-        ...error,
-        message: error.message,
-        stack: error.stack,
-    };
-}
-function deserializeError(serializedError) {
-    const error = new Error(serializedError.message);
-    Object.assign(error, serializedError);
-    return error;
-}
-const setPageErrorEvent = createEvent('setPageError');
-const initialState = null;
-const PageErrorStore = createReducer('pageError', initialState).on(setPageErrorEvent, (state, error) => error && serializeError(error));
-
-const PageErrorBoundary = (props) => {
-    const { children } = props;
-    const pageService = useDi(PAGE_SERVICE_TOKEN);
-    const url = useUrl();
-    const serializedError = useStore(PageErrorStore);
-    const error = useMemo(() => {
-        return serializedError && deserializeError(serializedError);
-    }, [serializedError]);
-    const errorHandlers = useDi({ token: ERROR_BOUNDARY_TOKEN, optional: true });
-    const fallbackFromDi = useDi({ token: ERROR_BOUNDARY_FALLBACK_COMPONENT_TOKEN, optional: true });
-    const fallback = pageService.resolveComponentFromConfig('errorBoundary');
-    return (jsx(UniversalErrorBoundary, { url: url, error: error, errorHandlers: errorHandlers, fallback: fallback, fallbackFromDi: fallbackFromDi, children: children }));
-};
-
-/**
- * Result component structure:
- *
- * <Root>
- *   <RootComponent>
- *    <LayoutComponent>
- *      <NestedLayoutComponent>
- *        <ErrorBoundaryComponent>
- *          <PageComponent />
- *        </ErrorBoundaryComponent>
- *      </NestedLayoutComponent>
- *    </LayoutComponent>
- *  </RootComponent>
- * </Root>
- *
- * All components separated for a few reasons:
- * - Page subtree can be rendered independently when Layout and Nested Layout the same
- * - Nested Layout can be rerendered only on its changes
- * - Layout can be rendered only on its changes
- */
-const LayoutRenderComponent = ({ children }) => {
-    const pageService = usePageService();
-    const LayoutComponent = pageService.resolveComponentFromConfig('layout');
-    const HeaderComponent = pageService.resolveComponentFromConfig('header');
-    const FooterComponent = pageService.resolveComponentFromConfig('footer');
-    const layout = useMemo(() => (jsx(LayoutComponent, { Header: HeaderComponent, Footer: FooterComponent, children: children })), [LayoutComponent, HeaderComponent, FooterComponent, children]);
-    return layout;
-};
-const NestedLayoutRenderComponent = ({ children }) => {
-    const pageService = usePageService();
-    const NestedLayoutComponent = pageService.resolveComponentFromConfig('nestedLayout');
-    const nestedLayout = useMemo(() => jsx(NestedLayoutComponent, { children: children }), [NestedLayoutComponent, children]);
-    return nestedLayout;
-};
-const PageRenderComponent = () => {
-    const pageService = usePageService();
-    const { pageComponent } = pageService.getConfig();
-    let PageComponent = pageService.getComponent(pageComponent);
-    if (!PageComponent) {
-        PageComponent = () => {
-            throw new Error(`Page component '${pageComponent}' not found`);
-        };
-    }
-    const page = useMemo(() => (jsx(PageErrorBoundary, { children: jsx(PageComponent, {}) })), [PageComponent]);
-    return page;
-};
-const Root = () => {
-    const pageRenderComponent = useMemo(() => jsx(PageRenderComponent, {}), []);
-    const nestedLayoutRenderComponent = useMemo(() => jsx(NestedLayoutRenderComponent, { children: pageRenderComponent }), [pageRenderComponent]);
-    return jsx(LayoutRenderComponent, { children: nestedLayoutRenderComponent });
-};
-
-function renderReact({ di }, context) {
-    const serverState = typeof window !== 'undefined' ? context.getState() : undefined;
-    return (jsx(Provider, { context: context, serverState: serverState, children: jsx(DIContext.Provider, { value: di, children: jsx(Root, {}) }) }));
-}
-
-const RENDER_TIMEOUT = 500;
-class HtmlWritable extends Writable {
-    constructor() {
-        super(...arguments);
-        this.chunks = [];
-        this.html = '';
-    }
-    getHtml() {
-        return this.html;
-    }
-    _write(chunk, encoding, callback) {
-        this.chunks.push(chunk);
-        callback();
-    }
-    _final(callback) {
-        this.html = Buffer.concat(this.chunks).toString();
-        callback();
-    }
-}
-class ReactRenderServer {
-    // eslint-disable-next-line sort-class-members/sort-class-members
-    constructor({ context, customRender, extendRender, di, renderMode, logger }) {
-        this.context = context;
-        this.customRender = customRender;
-        this.extendRender = extendRender;
-        this.di = di;
-        this.renderMode = renderMode;
-        this.log = logger('module-render');
-    }
-    render(extractor) {
-        var _a;
-        let renderResult = renderReact({ di: this.di }, this.context);
-        each((render) => {
-            renderResult = render(renderResult);
-        }, (_a = this.extendRender) !== null && _a !== void 0 ? _a : []);
-        renderResult = extractor.collectChunks(renderResult);
-        if (this.customRender) {
-            return this.customRender(renderResult);
-        }
-        if (process.env.__TRAMVAI_CONCURRENT_FEATURES && this.renderMode === 'streaming') {
-            return new Promise((resolve, reject) => {
-                const { renderToPipeableStream } = require('react-dom/server');
-                const htmlWritable = new HtmlWritable();
-                htmlWritable.on('finish', () => {
-                    resolve(htmlWritable.getHtml());
-                });
-                const start = Date.now();
-                const { log } = this;
-                log.info({
-                    event: 'streaming-render:start',
-                });
-                const { pipe, abort } = renderToPipeableStream(renderResult, {
-                    onAllReady() {
-                        log.info({
-                            event: 'streaming-render:complete',
-                            duration: Date.now() - start,
-                        });
-                        // here `write` will be called only once
-                        pipe(htmlWritable);
-                    },
-                    onError(error) {
-                        // error can be inside Suspense boundaries, this is not critical, continue rendering.
-                        // for criticall errors, this callback will be called with `onShellError`,
-                        // so this is a best place to error logging
-                        log.error({
-                            event: 'streaming-render:error',
-                            error,
-                        });
-                    },
-                    onShellError(error) {
-                        // always critical error, abort rendering
-                        reject(error);
-                    },
-                });
-                setTimeout(() => {
-                    abort();
-                    reject(new Error('React renderToPipeableStream timeout exceeded'));
-                }, RENDER_TIMEOUT);
-            });
-        }
-        const { renderToString } = require('react-dom/server');
-        return Promise.resolve(renderToString(renderResult));
-    }
-}
-
-const RenderChildrenComponent = ({ children }) => children;
-let LayoutModule = class LayoutModule {
-};
-LayoutModule = __decorate([
-    Module({
-        providers: [
-            {
-                provide: DEFAULT_LAYOUT_COMPONENT,
-                useFactory: ({ layoutOptions }) => {
-                    const options = composeLayoutOptions(layoutOptions);
-                    return createLayout(options);
-                },
-                deps: {
-                    layoutOptions: { token: LAYOUT_OPTIONS, optional: true },
-                },
-            },
-            {
-                provide: 'componentDefaultList',
-                multi: true,
-                useFactory: (components) => ({
-                    ...components,
-                    nestedLayoutDefault: RenderChildrenComponent,
-                }),
-                deps: {
-                    layoutDefault: DEFAULT_LAYOUT_COMPONENT,
-                    footerDefault: { token: DEFAULT_FOOTER_COMPONENT, optional: true },
-                    headerDefault: { token: DEFAULT_HEADER_COMPONENT, optional: true },
-                    errorBoundaryDefault: { token: DEFAULT_ERROR_BOUNDARY_COMPONENT, optional: true },
-                },
-            },
-        ],
-    })
-], LayoutModule);
-
-const providers = [
-    provide({
-        provide: COMBINE_REDUCERS,
-        multi: true,
-        useValue: PageErrorStore,
-    }),
-    provide({
-        provide: TRAMVAI_RENDER_MODE,
-        useValue: 'ssr',
-    }),
-];
+import { ResourcesInliner } from './resourcesInliner/resourcesInliner.es.js';
+import { RESOURCE_INLINER, RESOURCES_REGISTRY_CACHE } from './resourcesInliner/tokens.es.js';
+import { ResourcesRegistry } from './resourcesRegistry/index.es.js';
+import { PageBuilder } from './server/PageBuilder.es.js';
+import { htmlPageSchemaFactory } from './server/htmlPageSchema.es.js';
+import { ReactRenderServer } from './server/ReactRenderServer.es.js';
+export { ReactRenderServer } from './server/ReactRenderServer.es.js';
+import { LayoutModule } from './shared/LayoutModule.es.js';
+import { providers } from './shared/providers.es.js';
+import { setPageErrorEvent, PageErrorStore, deserializeError } from './shared/pageErrorStore.es.js';
+export { PageErrorStore, deserializeError, serializeError, setPageErrorEvent } from './shared/pageErrorStore.es.js';
 
 var RenderModule_1;
 const REQUEST_TTL = 5 * 60 * 1000;
@@ -1126,4 +285,4 @@ RenderModule = RenderModule_1 = __decorate([
     })
 ], RenderModule);
 
-export { DEFAULT_POLYFILL_CONDITION, PageErrorStore, ReactRenderServer, RenderModule, deserializeError, serializeError, setPageErrorEvent };
+export { DEFAULT_POLYFILL_CONDITION, RenderModule };