@angular/platform-server

Variables

• BEFORE_APP_SERIALIZED
• INITIAL_CONFIG
• ɵENABLE_DOM_EMULATION
• ɵINTERNAL_SERVER_PLATFORM_PROVIDERS
• ɵSERVER_CONTEXT
• ɵSERVER_RENDER_PROVIDERS
• VERSION

Functions

• ɵisHostAllowed()
• ɵrenderInternal()
• platformServer()
• provideServerRendering()
• renderApplication()
• renderModule()

Classes

• ɵDominoAdapter

  • createHtmlDocument()
  • dispatchEvent()
  • getBaseHref()
  • getCookie()
  • getDefaultDocument()
  • getGlobalEventTarget()
  • getUserAgent()
  • isElementNode()
  • isShadowRoot()
  • makeCurrent()
  • supportsDOMEvents
• PlatformState

  • getDocument()
  • ɵfac
  • ɵprov
  • renderToString()
• ServerModule

  • ɵfac
  • ɵinj
  • ɵmod

Interfaces

• PlatformConfig

  • document
  • url

Enums

• RuntimeErrorCode

  • DISABLED_DOM_EMULATION_IN_NON_BROWSER
  • GET_COOKIE_NOT_IMPLEMENTED
  • HOST_NOT_ALLOWED
  • INVALID_URL
  • PROTOCOL_RELATIVE_URL_NOT_ALLOWED
  • SUSPICIOUS_URL_CHANGE_ORIGIN
  • XHR_NOT_LOADED

variable BEFORE_APP_SERIALIZED

const BEFORE_APP_SERIALIZED: InjectionToken<readonly (() => void | Promise<void>)[]>;

• A function that will be executed when calling renderApplication or renderModule just before current platform state is rendered to string.

variable INITIAL_CONFIG

const INITIAL_CONFIG: InjectionToken<PlatformConfig>;

• The DI token for setting the initial config for the platform.

variable ɵENABLE_DOM_EMULATION

const ɵENABLE_DOM_EMULATION: InjectionToken<boolean>;

variable ɵINTERNAL_SERVER_PLATFORM_PROVIDERS

const ɵINTERNAL_SERVER_PLATFORM_PROVIDERS: StaticProvider[];

variable ɵSERVER_CONTEXT

const ɵSERVER_CONTEXT: InjectionToken<string>;

• An internal token that allows providing extra information about the server context (e.g. whether SSR or SSG was used). The value is a string and characters other than [a-zA-Z0-9-] are removed. See the default value in DEFAULT_SERVER_CONTEXT const.

variable ɵSERVER_RENDER_PROVIDERS

const ɵSERVER_RENDER_PROVIDERS: Provider[];

variable VERSION

const VERSION: Version;

function ɵisHostAllowed

ɵisHostAllowed: (hostname: string, allowedHosts: ReadonlySet<string>) => boolean;

• Checks if the hostname is allowed.

  Parameter hostname

  The hostname to check.

  Parameter allowedHosts

  A set of allowed hostnames.

  Returns

  true if the hostname is allowed, false otherwise. Used also in @angular/ssr.

function ɵrenderInternal

ɵrenderInternal: (
    platformRef: PlatformRef,
    applicationRef: ApplicationRef
) => Promise<string>;

• Renders an Angular application to a string.

  Parameter platformRef

  Reference to the Angular platform.

  Parameter applicationRef

  Reference to the Angular application.

  Returns

  A promise that resolves to the rendered string.

function platformServer

platformServer: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;

• Creates a server-side instance of an Angular platform.

  This platform should be used when performing server-side rendering of an Angular application. Standalone applications can be bootstrapped on the server using the bootstrapApplication function from @angular/platform-browser. When using bootstrapApplication, the platformServer should be created first and passed to the bootstrap function using the BootstrapContext.

function provideServerRendering

provideServerRendering: (options?: {
    maxResponseBodySize: number;
}) => EnvironmentProviders;

• Sets up providers necessary to enable server rendering functionality for the application.

  Parameter options

  An object to configure the server providers. Currently supports the following options: - maxResponseBodySize: The maximum allowed response body size when using the Fetch API.

  Basic example of how you can add server support to your application:

  bootstrapApplication(AppComponent, {
    providers: [provideServerRendering()]
  });

  Returns

  A set of providers to setup the server.

function renderApplication

renderApplication: (
    bootstrap: (context: BootstrapContext) => Promise<ApplicationRef>,
    options: {
        document?: string | Document;
        url?: string;
        platformProviders?: Provider[];
        allowedHosts?: Readonly<string>[];
    }
) => Promise<string>;

• Bootstraps an instance of an Angular application and renders it to a string.

  import { BootstrapContext, bootstrapApplication } from '@angular/platform-browser';
  import { renderApplication } from '@angular/platform-server';
  import { ApplicationConfig } from '@angular/core';
  import { AppComponent } from './app.component';
  
  const appConfig: ApplicationConfig = { providers: [...] };
  const bootstrap = (context: BootstrapContext) =>
    bootstrapApplication(AppComponent, config, context);
  const output = await renderApplication(bootstrap);

  Parameter bootstrap

  A method that when invoked returns a promise that returns an ApplicationRef instance once resolved. The method is invoked with an Injector instance that provides access to the platform-level dependency injection context.

  Parameter options

  Additional configuration for the render operation: - document - the document of the page to render, either as an HTML string or as a reference to the document instance. - url - the URL for the current render request. - platformProviders - the platform level providers for the current render request. - allowedHosts - the allowed hosts list for host validation in server-side rendering.

  Returns

  A Promise, that returns serialized (to a string) rendered page, once resolved.

function renderModule

renderModule: <T>(
    moduleType: Type<T>,
    options: {
        document?: string | Document;
        url?: string;
        extraProviders?: StaticProvider[];
        allowedHosts?: Readonly<string>[];
    }
) => Promise<string>;

• Bootstraps an application using provided NgModule and serializes the page content to string.

  Parameter moduleType

  A reference to an NgModule that should be used for bootstrap.

  Parameter options

  Additional configuration for the render operation: - document - the document of the page to render, either as an HTML string or as a reference to the document instance. - url - the URL for the current render request. - extraProviders - set of platform level providers for the current render request. - allowedHosts - the allowed hosts list for host validation in server-side rendering.