Module for rendering React application on the server and in the browser
Module contains the logic for generating HTML pages, starting from getting current page component, and finishing with the rendering result HTML using the @tinkoff/htmlpagebuilder
library.
This module includes code for creating top-level React component with all necessary providers composition, and page and layout components from the current route.
You need to install @tramvai/module-render
npm install @tramvai/module-render
And connect to the project
import { createApp } from '@tramvai/core';
import { RenderModule } from '@tramvai/module-render';
createApp({
name: 'tincoin',
modules: [RenderModule],
});
More information about Strict Mode can be found in the official documentation.
To set the mode, you must pass the useStrictMode
parameter when initializing the RenderModule
.
RenderModule.forRoot({ useStrictMode: true });
For static assets (JS, CSS, fonts, etc.) we create special resources registry module, which allow to provide in DI list of resources, and then render them to specifics slots in final HTML.
Example:
createApp({
providers: [
{
provide: RENDER_SLOTS,
multi: true,
useValue: [
{
type: ResourceType.inlineScript, // inlineScript wrap payload in tag <script>
slot: ResourceSlot.HEAD_CORE_SCRIPTS, // define position where in HTML will be included resource
payload: 'alert("render")',
},
{
type: ResourceType.asIs, // asIs just add payload as a string, without special processing
slot: ResourceSlot.BODY_TAIL,
payload: '<div>hello from render slots</div>',
},
],
},
],
});
- type - presets for different resources types
- slot - slot in HTML where resource will be included
- payload - information that will be rendered
Available slots
@inline src/server/constants/slots.ts
Layout of slots in the HTML page
@inline src/server/htmlPageSchema.ts
How to add assets loading to a page
A large number of resource files creates problems when loading the page, because the browser has to create a lot of connections to small files
To optimize page loading, we've added the ability to include some resources directly in the incoming HTML from the server. To avoid inlining everything at all, we've added the ability to set an upper limit for file size.
Since version 0.60.7
inlining for styles is enabled by default, CSS files smaller than 40kb before gzip (+-10kb after gzip) are inlined.
To override these settings, add a provider specifying types of resources to be inlined (styles and/or scripts) and an upper limit for file size (in bytes, before gzip):
import { RESOURCE_INLINE_OPTIONS } from '@tramvai/tokens-render';
import { ResourceType } from '@tramvai/tokens-render';
import { provide } from '@tramvai/core';
provide({
provide: RESOURCE_INLINE_OPTIONS,
useValue: {
types: [ResourceType.script, ResourceType.style], // Turn on for a CSS and JS files
threshold: 1024, // 1kb unzipped
},
}),
All scripts and styles (depending on the settings) registered through the ResourcesRegistry
are inlined.
File uploading to the server occurs in lazy mode, asynchronously. This means that there will be no inlining when the page first loads. It also means that there is no extra waiting for resources to load on the server side. Once the file is in the cache it will be inline. The cache has a TTL of 30 minutes and there is no resetting of the cache.
To speed up data loading, we've added a preloading system for resources and asynchronous chunks, which works according to the following scenario:
- After rendering the application, we get information about all the CSS, JS bundles and asynchronous chunks used in the application
- Next we add all the CSS to the preload tag and add onload event on them. We need to load the blocking resources as quickly as possible.
- When loading any CSS file, onload event will be fired (only once time) and add all preload tags to the necessary JS files
There are 2 main ways how you can add resources to your application
- The
RENDER_SLOTS
token, where you can pass a list of resources, such as HTML markup, inline scripts, script tag - Token
RESOURCES_REGISTRY
to get the resource manager, and register the desired resources manually
Example:
Application example
@inline ../../../examples/how-to/render-add-resources/index.tsx
tramvai
will automatically detect React version, and use hydrateRoot API on the client for 18+ version.
Before switch to React 18, we recommended to activate Strict Mode in your application. In Strict Mode which React warns about using the legacy API.
To connect, you must configure the RenderModule
:
modules: [
RenderModule.forRoot({ useStrictMode: true })
]
If you have a module or providers that define RENDER_SLOTS
or use RESOURCES_REGISTRY
, it is convenient to use special utilities to test them separately
import {
RENDER_SLOTS,
ResourceSlot,
RESOURCES_REGISTRY,
ResourceType,
} from '@tramvai/tokens-render';
import { testPageResources } from '@tramvai/module-render/tests';
import { CustomModule } from './module';
import { providers } from './providers';
describe('testPageResources', () => {
it('modules', async () => {
const { render } = testPageResources({
modules: [CustomModule],
});
const { head } = render();
expect(head).toMatchInlineSnapshot(`
"
<meta charset=\\"UTF-8\\">
<script>console.log(\\"from module!\\")</script>
"
`);
});
it('providers', async () => {
const { render, runLine } = testPageResources({
providers,
});
expect(render().body).toMatchInlineSnapshot(`
"
"
`);
await runLine(commandLineListTokens.resolvePageDeps);
expect(render().body).toMatchInlineSnapshot(`
"
<script defer=\\"defer\\" charset=\\"utf-8\\" crossorigin=\\"anonymous\\" src=\\"https://scripts.org/script.js\\"></script>
<span>I\`m body!!!</span>
"
`);
});
});