@tramvai/module-render 2.70.1 → 2.72.0

package/lib/server.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var react$1 = require('react');
-var server$1 = require('react-dom/server');
+var react = require('react');
+var server = require('react-dom/server');
 var core = require('@tramvai/core');
 var tokensCommon = require('@tramvai/tokens-common');
 var tokensRouter = require('@tramvai/tokens-router');
@@ -12,894 +12,18 @@ var moduleClientHints = require('@tramvai/module-client-hints');
 var tokensRender = require('@tramvai/tokens-render');
 var dippy = require('@tinkoff/dippy');
 var tokensServerPrivate = require('@tramvai/tokens-server-private');
-var react = require('@tramvai/react');
+var react$1 = require('@tramvai/react');
 var url = require('@tinkoff/url');
 var userAgent = require('@tinkoff/user-agent');
-var isUndefined = require('@tinkoff/utils/is/undefined');
-var isEmpty = require('@tinkoff/utils/is/empty');
-var fetch = require('node-fetch');
-var startsWith = require('@tinkoff/utils/string/startsWith');
-var toArray = require('@tinkoff/utils/array/toArray');
-var flatten = require('@tinkoff/utils/array/flatten');
-var htmlpagebuilder = require('@tinkoff/htmlpagebuilder');
-var safeStrings = require('@tramvai/safe-strings');
-var server = require('@loadable/server');
-var has = require('@tinkoff/utils/object/has');
-var last = require('@tinkoff/utils/array/last');
-var experiments = require('@tramvai/experiments');
-var uniq = require('@tinkoff/utils/array/uniq');
-var path = require('path');
-var each = require('@tinkoff/utils/array/each');
-var path$1 = require('@tinkoff/utils/object/path');
-var inline_inline = require('./server_inline.inline.js');
-var stream = require('stream');
-var jsxRuntime = require('react/jsx-runtime');
-var state = require('@tramvai/state');
-var moduleRouter = require('@tramvai/module-router');
-var layoutFactory = require('@tinkoff/layout-factory');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n["default"] = e;
-    return n;
-}
-
-var isUndefined__default = /*#__PURE__*/_interopDefaultLegacy(isUndefined);
-var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
-var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
-var startsWith__default = /*#__PURE__*/_interopDefaultLegacy(startsWith);
-var toArray__default = /*#__PURE__*/_interopDefaultLegacy(toArray);
-var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten);
-var has__default = /*#__PURE__*/_interopDefaultLegacy(has);
-var last__default = /*#__PURE__*/_interopDefaultLegacy(last);
-var uniq__default = /*#__PURE__*/_interopDefaultLegacy(uniq);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var each__default = /*#__PURE__*/_interopDefaultLegacy(each);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$1);
-
-const thirtySeconds = 1000 * 30;
-const getFileContentLength = async (url) => {
-    const info = await fetch__default["default"](url, { method: 'HEAD', timeout: thirtySeconds });
-    return info.headers.get('content-length');
-};
-const getFile = async (url) => {
-    const fileResponse = await fetch__default["default"](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__default["default"](prefix, resourceUrl));
-const toHttpsUrl = (resourceUrl) => {
-    if (resourceUrl.indexOf('//localhost') !== -1) {
-        return resourceUrl;
-    }
-    if (startsWith__default["default"]('http://', resourceUrl)) {
-        return resourceUrl.replace('http://', 'https://');
-    }
-    if (startsWith__default["default"]('//', resourceUrl)) {
-        return resourceUrl.replace('//', 'https://');
-    }
-    return resourceUrl;
-};
-const urlReplacerCreator = (resourceUrl) => (str, leftGroup, _, extractedUrl, rightGroup) => {
-    return isAbsoluteUrl(extractedUrl)
-        ? str
-        : `${leftGroup}${url.resolve(toHttpsUrl(resourceUrl), extractedUrl)}${rightGroup}`;
-};
-const processFile = (resource, file) => {
-    if (resource.type === tokensRender.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 tokensRender.ResourceType.style:
-            return tokensRender.ResourceType.inlineStyle;
-        case tokensRender.ResourceType.script:
-            return tokensRender.ResourceType.inlineScript;
-        default:
-            return type;
-    }
-};
-const getResourceUrl = (resource) => {
-    if (isEmpty__default["default"](resource.payload) || !url.isAbsoluteUrl(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__default["default"](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 !== tokensRender.ResourceType.preloadLink) {
-            // only checking preload-links
-            return true;
-        }
-        const url = getResourceUrl(resource);
-        if (isUndefined__default["default"](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__default["default"](resourceInlineThreshold)) {
-            return false;
-        }
-        const url = getResourceUrl(resource);
-        if (isUndefined__default["default"](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__default["default"](url)) {
-            // usually, it should not happen but anyway check it for safety
-            return [resource];
-        }
-        const text = this.getFilesCache(url).get(url);
-        if (isEmpty__default["default"](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: tokensRender.ResourceType.asIs,
-                payload: `<!-- Inlined file ${url} -->`,
-            });
-        }
-        result.push({
-            ...resource,
-            type: getInlineType(resource.type),
-            payload: text,
-        });
-        if (resource.type === tokensRender.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: tokensRender.ResourceType.style,
-                payload: null,
-                attrs: {
-                    'data-href': resource.payload,
-                },
-            });
-        }
-        return result;
-    }
-}
-
-/**
- * @description
- * Инлайнер ресурсов - используется на сервере для регистрации файлов, которые должны быть вставлены
- * в итоговую html-страницу в виде ссылки на файл или заинлайнеными полностью
- */
-const RESOURCE_INLINER = dippy.createToken('resourceInliner');
-/**
- * @description
- * Кэш загруженных ресурсов.
- */
-const RESOURCES_REGISTRY_CACHE = dippy.createToken('resourcesRegistryCache');
-
-class ResourcesRegistry {
-    constructor({ resourceInliner }) {
-        this.resources = new Set();
-        this.resourceInliner = resourceInliner;
-    }
-    register(resourceOrResources) {
-        toArray__default["default"](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__default["default"](uniq__default["default"](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__default["default"](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__namespace.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 = experiments.isFileSystemPageComponent(pageComponent)
-        ? experiments.fileSystemPageToWebpackChunkName(pageComponent)
-        : last__default["default"](bundle.split('/'));
-    const webpackStats = await fetchWebpackStats({ modern });
-    const { publicPath, assetsByChunkName } = webpackStats;
-    const bundles = has__default["default"]('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: tokensRender.ResourceType.inlineScript,
-            slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
-            payload: `window.ap = ${`"${process.env.ASSETS_PREFIX}"`};`,
-        });
-    }
-    styles.map((style) => result.push({
-        type: tokensRender.ResourceType.style,
-        slot: tokensRender.ResourceSlot.HEAD_CORE_STYLES,
-        payload: genHref(style),
-        attrs: {
-            'data-critical': 'true',
-            onload: `${PRELOAD_JS}()`,
-        },
-    }));
-    baseScripts.map((script) => result.push({
-        type: tokensRender.ResourceType.script,
-        slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
-        payload: genHref(script),
-        attrs: {
-            'data-critical': 'true',
-        },
-    }));
-    scripts.map((script) => result.push({
-        type: tokensRender.ResourceType.script,
-        slot: tokensRender.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: tokensRender.ResourceType.inlineScript,
-            slot: tokensRender.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__default["default"]((res) => {
-        if (res.type === 'script' && path__default["default"](['attrs', 'data-critical'], res)) {
-            jsUrls.push(res.payload);
-        }
-    }, pageResources);
-    return {
-        type: tokensRender.ResourceType.inlineScript,
-        slot: tokensRender.ResourceSlot.HEAD_PERFORMANCE,
-        payload: `window.${PRELOAD_JS}=(${inline_inline.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__default["default"](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 server.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: tokensRender.ResourceType.asIs,
-            slot: tokensRender.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">${safeStrings.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 htmlpagebuilder.buildPage({
-            slotHandlers: resultSlotHandlers,
-            description: this.htmlPageSchema,
-        });
-    }
-    async renderApp(extractor) {
-        const html = await this.reactRender.render(extractor);
-        this.renderSlots = this.renderSlots.concat({
-            type: tokensRender.ResourceType.asIs,
-            slot: tokensRender.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, } = tokensRender.ResourceSlot;
-const htmlPageSchemaFactory = ({ htmlAttrs, }) => {
-    return [
-        htmlpagebuilder.staticRender('<!DOCTYPE html>'),
-        htmlpagebuilder.staticRender(`<html ${formatAttributes(htmlAttrs, 'html')}>`),
-        htmlpagebuilder.staticRender('<head>'),
-        htmlpagebuilder.staticRender('<meta charset="UTF-8">'),
-        htmlpagebuilder.dynamicRender(HEAD_META),
-        htmlpagebuilder.dynamicRender(HEAD_PERFORMANCE),
-        htmlpagebuilder.dynamicRender(HEAD_CORE_STYLES),
-        htmlpagebuilder.dynamicRender(HEAD_POLYFILLS),
-        htmlpagebuilder.dynamicRender(HEAD_DYNAMIC_SCRIPTS),
-        htmlpagebuilder.dynamicRender(HEAD_CORE_SCRIPTS),
-        htmlpagebuilder.dynamicRender(HEAD_ANALYTICS),
-        htmlpagebuilder.dynamicRender(HEAD_ICONS),
-        htmlpagebuilder.staticRender('</head>'),
-        htmlpagebuilder.staticRender(`<body ${formatAttributes(htmlAttrs, 'body')}>`),
-        htmlpagebuilder.dynamicRender(BODY_START),
-        // react app
-        htmlpagebuilder.dynamicRender(REACT_RENDER),
-        htmlpagebuilder.dynamicRender(BODY_END),
-        htmlpagebuilder.dynamicRender(BODY_TAIL_ANALYTICS),
-        htmlpagebuilder.dynamicRender(BODY_TAIL),
-        htmlpagebuilder.staticRender('</body>'),
-        htmlpagebuilder.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 = state.createEvent('setPageError');
-const initialState = null;
-const PageErrorStore = state.createReducer('pageError', initialState).on(setPageErrorEvent, (state, error) => error && serializeError(error));
-
-const PageErrorBoundary = (props) => {
-    const { children } = props;
-    const pageService = react.useDi(tokensRouter.PAGE_SERVICE_TOKEN);
-    const url = moduleRouter.useUrl();
-    const serializedError = state.useStore(PageErrorStore);
-    const error = react$1.useMemo(() => {
-        return serializedError && deserializeError(serializedError);
-    }, [serializedError]);
-    const errorHandlers = react.useDi({ token: react.ERROR_BOUNDARY_TOKEN, optional: true });
-    const fallbackFromDi = react.useDi({ token: react.ERROR_BOUNDARY_FALLBACK_COMPONENT_TOKEN, optional: true });
-    const fallback = pageService.resolveComponentFromConfig('errorBoundary');
-    return (jsxRuntime.jsx(react.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 = moduleRouter.usePageService();
-    const LayoutComponent = pageService.resolveComponentFromConfig('layout');
-    const HeaderComponent = pageService.resolveComponentFromConfig('header');
-    const FooterComponent = pageService.resolveComponentFromConfig('footer');
-    const layout = react$1.useMemo(() => (jsxRuntime.jsx(LayoutComponent, { Header: HeaderComponent, Footer: FooterComponent, children: children })), [LayoutComponent, HeaderComponent, FooterComponent, children]);
-    return layout;
-};
-const NestedLayoutRenderComponent = ({ children }) => {
-    const pageService = moduleRouter.usePageService();
-    const NestedLayoutComponent = pageService.resolveComponentFromConfig('nestedLayout');
-    const nestedLayout = react$1.useMemo(() => jsxRuntime.jsx(NestedLayoutComponent, { children: children }), [NestedLayoutComponent, children]);
-    return nestedLayout;
-};
-const PageRenderComponent = () => {
-    const pageService = moduleRouter.usePageService();
-    const { pageComponent } = pageService.getConfig();
-    let PageComponent = pageService.getComponent(pageComponent);
-    if (!PageComponent) {
-        PageComponent = () => {
-            throw new Error(`Page component '${pageComponent}' not found`);
-        };
-    }
-    const page = react$1.useMemo(() => (jsxRuntime.jsx(PageErrorBoundary, { children: jsxRuntime.jsx(PageComponent, {}) })), [PageComponent]);
-    return page;
-};
-const Root = () => {
-    const pageRenderComponent = react$1.useMemo(() => jsxRuntime.jsx(PageRenderComponent, {}), []);
-    const nestedLayoutRenderComponent = react$1.useMemo(() => jsxRuntime.jsx(NestedLayoutRenderComponent, { children: pageRenderComponent }), [pageRenderComponent]);
-    return jsxRuntime.jsx(LayoutRenderComponent, { children: nestedLayoutRenderComponent });
-};
-
-function renderReact({ di }, context) {
-    const serverState = typeof window !== 'undefined' ? context.getState() : undefined;
-    return (jsxRuntime.jsx(state.Provider, { context: context, serverState: serverState, children: jsxRuntime.jsx(react.DIContext.Provider, { value: di, children: jsxRuntime.jsx(Root, {}) }) }));
-}
-
-const RENDER_TIMEOUT = 500;
-class HtmlWritable extends stream.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__default["default"]((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 = tslib.__decorate([
-    core.Module({
-        providers: [
-            {
-                provide: tokensRender.DEFAULT_LAYOUT_COMPONENT,
-                useFactory: ({ layoutOptions }) => {
-                    const options = layoutFactory.composeLayoutOptions(layoutOptions);
-                    return layoutFactory.createLayout(options);
-                },
-                deps: {
-                    layoutOptions: { token: tokensRender.LAYOUT_OPTIONS, optional: true },
-                },
-            },
-            {
-                provide: 'componentDefaultList',
-                multi: true,
-                useFactory: (components) => ({
-                    ...components,
-                    nestedLayoutDefault: RenderChildrenComponent,
-                }),
-                deps: {
-                    layoutDefault: tokensRender.DEFAULT_LAYOUT_COMPONENT,
-                    footerDefault: { token: tokensRender.DEFAULT_FOOTER_COMPONENT, optional: true },
-                    headerDefault: { token: tokensRender.DEFAULT_HEADER_COMPONENT, optional: true },
-                    errorBoundaryDefault: { token: tokensRender.DEFAULT_ERROR_BOUNDARY_COMPONENT, optional: true },
-                },
-            },
-        ],
-    })
-], LayoutModule);
-
-const providers = [
-    core.provide({
-        provide: tokensCommon.COMBINE_REDUCERS,
-        multi: true,
-        useValue: PageErrorStore,
-    }),
-    core.provide({
-        provide: tokensRender.TRAMVAI_RENDER_MODE,
-        useValue: 'ssr',
-    }),
-];
+var resourcesInliner = require('./resourcesInliner/resourcesInliner.js');
+var tokens = require('./resourcesInliner/tokens.js');
+var index = require('./resourcesRegistry/index.js');
+var PageBuilder = require('./server/PageBuilder.js');
+var htmlPageSchema = require('./server/htmlPageSchema.js');
+var ReactRenderServer = require('./server/ReactRenderServer.js');
+var LayoutModule = require('./shared/LayoutModule.js');
+var providers = require('./shared/providers.js');
+var pageErrorStore = require('./shared/pageErrorStore.js');
 
 var RenderModule_1;
 const REQUEST_TTL = 5 * 60 * 1000;
@@ -921,18 +45,18 @@ exports.RenderModule = RenderModule_1 = class RenderModule {
 };
 exports.RenderModule = RenderModule_1 = tslib.__decorate([
     core.Module({
-        imports: [moduleClientHints.ClientHintsModule, LayoutModule],
+        imports: [moduleClientHints.ClientHintsModule, LayoutModule.LayoutModule],
         providers: [
-            ...providers,
+            ...providers.providers,
             core.provide({
                 provide: tokensRender.RESOURCES_REGISTRY,
-                useClass: ResourcesRegistry,
+                useClass: index.ResourcesRegistry,
                 deps: {
-                    resourceInliner: RESOURCE_INLINER,
+                    resourceInliner: tokens.RESOURCE_INLINER,
                 },
             }),
             core.provide({
-                provide: RESOURCES_REGISTRY_CACHE,
+                provide: tokens.RESOURCES_REGISTRY_CACHE,
                 scope: dippy.Scope.SINGLETON,
                 useFactory: ({ createCache }) => {
                     return {
@@ -946,11 +70,11 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                 },
             }),
             core.provide({
-                provide: RESOURCE_INLINER,
+                provide: tokens.RESOURCE_INLINER,
                 scope: dippy.Scope.SINGLETON,
-                useClass: ResourcesInliner,
+                useClass: resourcesInliner.ResourcesInliner,
                 deps: {
-                    resourcesRegistryCache: RESOURCES_REGISTRY_CACHE,
+                    resourcesRegistryCache: tokens.RESOURCES_REGISTRY_CACHE,
                     resourceInlineThreshold: { token: tokensRender.RESOURCE_INLINE_OPTIONS, optional: true },
                     logger: tokensCommon.LOGGER_TOKEN,
                 },
@@ -968,7 +92,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                             // assuming that there was an error when rendering the page, try to render again with ErrorBoundary
                             try {
                                 log.info({ event: 'render-page-boundary-start' });
-                                context.dispatch(setPageErrorEvent(error));
+                                context.dispatch(pageErrorStore.setPageErrorEvent(error));
                                 html = await htmlBuilder.flow();
                                 log.info({ event: 'render-page-boundary-success' });
                             }
@@ -979,7 +103,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                                 throw error;
                             }
                         }
-                        const pageRenderError = context.getState(PageErrorStore);
+                        const pageRenderError = context.getState(pageErrorStore.PageErrorStore);
                         // log send-server-error only after successful Page Boundary render,
                         // otherwise this event will be logged in default error handler
                         if (pageRenderError) {
@@ -993,7 +117,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                                 log.error({
                                     event: 'send-server-error',
                                     message: 'Page render error, switch to page boundary',
-                                    error: deserializeError(pageRenderError),
+                                    error: pageErrorStore.deserializeError(pageRenderError),
                                     requestInfo,
                                 });
                             }
@@ -1018,7 +142,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
             }),
             core.provide({
                 provide: 'htmlBuilder',
-                useClass: PageBuilder,
+                useClass: PageBuilder.PageBuilder,
                 deps: {
                     reactRender: 'reactRender',
                     pageService: tokensRouter.PAGE_SERVICE_TOKEN,
@@ -1035,7 +159,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
             }),
             core.provide({
                 provide: 'reactRender',
-                useClass: ReactRenderServer,
+                useClass: ReactRenderServer.ReactRenderServer,
                 deps: {
                     context: tokensCommon.CONTEXT_TOKEN,
                     customRender: { token: tokensRender.CUSTOM_RENDER, optional: true },
@@ -1047,7 +171,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
             }),
             core.provide({
                 provide: 'htmlPageSchema',
-                useFactory: htmlPageSchemaFactory,
+                useFactory: htmlPageSchema.htmlPageSchemaFactory,
                 deps: {
                     htmlAttrs: tokensRender.HTML_ATTRS,
                 },
@@ -1097,7 +221,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                         let body;
                         try {
                             log.info({ event: 'render-root-boundary-start' });
-                            body = server$1.renderToString(react$1.createElement(RootErrorBoundary, { error, url: url.parse(request.url) }));
+                            body = server.renderToString(react.createElement(RootErrorBoundary, { error, url: url.parse(request.url) }));
                             log.info({ event: 'render-root-boundary-success' });
                             const status = error.status || error.httpStatus || 500;
                             // log send-server-error only after successful Root Boundary render,
@@ -1127,7 +251,7 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
                     };
                 },
                 deps: {
-                    RootErrorBoundary: { token: react.ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN, optional: true },
+                    RootErrorBoundary: { token: react$1.ROOT_ERROR_BOUNDARY_COMPONENT_TOKEN, optional: true },
                     logger: tokensCommon.LOGGER_TOKEN,
                 },
             }),
@@ -1162,12 +286,12 @@ exports.RenderModule = RenderModule_1 = tslib.__decorate([
     })
 ], exports.RenderModule);
 
+exports.ReactRenderServer = ReactRenderServer.ReactRenderServer;
+exports.PageErrorStore = pageErrorStore.PageErrorStore;
+exports.deserializeError = pageErrorStore.deserializeError;
+exports.serializeError = pageErrorStore.serializeError;
+exports.setPageErrorEvent = pageErrorStore.setPageErrorEvent;
 exports.DEFAULT_POLYFILL_CONDITION = DEFAULT_POLYFILL_CONDITION;
-exports.PageErrorStore = PageErrorStore;
-exports.ReactRenderServer = ReactRenderServer;
-exports.deserializeError = deserializeError;
-exports.serializeError = serializeError;
-exports.setPageErrorEvent = setPageErrorEvent;
 Object.keys(tokensRender).forEach(function (k) {
     if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
         enumerable: true,