TypeScript platform-server.platformDynamicServer函数代码示例

export default createServerRenderer(params => {
    const providers = [
        { provide: INITIAL_CONFIG, useValue: { document: '<app></app>', url: params.url } },
        { provide: APP_BASE_HREF, useValue: params.baseUrl },
        { provide: 'BASE_URL', useValue: params.origin + params.baseUrl },
    ];

    return platformDynamicServer(providers).bootstrapModule(AppModule).then(moduleRef => {
        const appRef: ApplicationRef = moduleRef.injector.get(ApplicationRef);
        const state = moduleRef.injector.get(PlatformState);
        const zone = moduleRef.injector.get(NgZone);

        return new Promise<RenderResult>((resolve, reject) => {
            zone.onError.subscribe((errorInfo: any) => reject(errorInfo));
            appRef.isStable.first(isStable => isStable).subscribe(() => {
                // Because 'onStable' fires before 'onError', we have to delay slightly before
                // completing the request in case there's an error to report
                setImmediate(() => {
                    resolve({
                        html: state.renderToString()
                    });
                    moduleRef.destroy();
                });
            });
        });
    });
});

	return function (filePath: string, options: { req: Request, res?: Response }, callback: Send): void {
		try {
			const moduleFactory = setupOptions.bootstrap;

			if (!moduleFactory)
				throw new Error('You must pass in a NgModule or NgModuleFactory to be bootstrapped');

			const extraProviders: any = setupOptions.providers.concat(
				getReqResProviders(options.req, options.res),
				[
					{
						provide: INITIAL_CONFIG,
						useValue: {
							document: getDocument(filePath),
							url: options.req.originalUrl
						}
					}
				]);

			const moduleRefPromise = setupOptions.aot ?
				platformServer(extraProviders).bootstrapModuleFactory(moduleFactory as NgModuleFactory<{}>) :
				platformDynamicServer(extraProviders).bootstrapModule(moduleFactory as Type<{}>);

			moduleRefPromise.then((moduleRef: NgModuleRef<{}>) => {
				handleModuleRef(moduleRef, callback);
			});
		} catch (e) {
			callback(e);
		}
	};

export function ngExpressEngine(setupOptions: NgSetupOptions) {

  const compilerFactory: CompilerFactory = platformDynamicServer().injector.get(CompilerFactory);
  const compiler: Compiler = compilerFactory.createCompiler([
    {
      providers: [
        { provide: ResourceLoader, useClass: FileLoader, deps: [] }
      ]
    }
  ]);

  return function (filePath: string, options: RenderOptions, callback: (err?: Error | null, html?: string) => void) {

    options.providers = options.providers || [];

    try {
      const moduleOrFactory = options.bootstrap || setupOptions.bootstrap;

      if (!moduleOrFactory) {
        throw new Error('You must pass in a NgModule or NgModuleFactory to be bootstrapped');
      }

      setupOptions.providers = setupOptions.providers || [];

      const extraProviders = setupOptions.providers.concat(
        options.providers,
        getReqResProviders(options.req, options.res),
        [
          {
            provide: INITIAL_CONFIG,
            useValue: {
              document: getDocument(filePath),
              url: options.req.originalUrl
            }
          }
        ]);

      getFactory(moduleOrFactory, compiler)
        .then(factory => {
          return renderModuleFactory(factory, {
            extraProviders: extraProviders
          });
        })
        .then((html: string) => {
          callback(null, html);
        }, (err) => {
          callback(err);
        });
    } catch (err) {
      callback(err);
    }
  };
}

 it('should bootstrap', async(() => {
      var body = writeBody('<app></app>');
      platformDynamicServer().bootstrapModule(ExampleModule).then(() => {
        expect(getDOM().getText(body)).toEqual('Works!');
      });
    }));

import 'core-js/proposals/reflect-metadata';
import {platformDynamicServer, renderModule} from '@angular/platform-server';
import {AppModule} from './app.module';

AppModule.testProp = 'testing';

platformDynamicServer().bootstrapModule(AppModule);

renderModule(AppModule, {
  document: '<app-root></app-root>',
  url: '/'
});

export function ngAspnetCoreEngine(
  options: IEngineOptions
): Promise<{ html: string, globals: { styles: string, title: string, meta: string, transferData?: {}, [key: string]: any } }> {

  options.providers = options.providers || [];

  const compilerFactory: CompilerFactory = platformDynamicServer().injector.get(CompilerFactory);
  const compiler: Compiler = compilerFactory.createCompiler([
    {
      providers: [
        { provide: ResourceLoader, useClass: FileLoader }
      ]
    }
  ]);

  return new Promise((resolve, reject) => {

    try {
      const moduleOrFactory = options.ngModule;
      if (!moduleOrFactory) {
        throw new Error('You must pass in a NgModule or NgModuleFactory to be bootstrapped');
      }

      const extraProviders = options.providers.concat(
        options.providers,
        [
          {
            provide: INITIAL_CONFIG,
            useValue: {
              document: options.appSelector,
              url: options.request.url
            }
          },
          {
            provide: ORIGIN_URL,
            useValue: options.request.origin
          }, {
            provide: REQUEST,
            useValue: options.request.data.request
          }
        ]
      );

      const platform = platformServer(extraProviders);

      getFactory(moduleOrFactory, compiler)
        .then((factory: NgModuleFactory<{}>) => {

          return platform.bootstrapModuleFactory(factory).then((moduleRef: NgModuleRef<{}>) => {

            const state: PlatformState = moduleRef.injector.get(PlatformState);
            const appRef: ApplicationRef = moduleRef.injector.get(ApplicationRef);

            appRef.isStable
              .filter((isStable: boolean) => isStable)
              .first()
              .subscribe((stable) => {

                // Fire the TransferState Cache
                const bootstrap = moduleRef.instance['ngOnBootstrap'];
                bootstrap && bootstrap();

                // The parse5 Document itself
                const AST_DOCUMENT = state.getDocument();

                // Strip out the Angular application
                const htmlDoc = state.renderToString();

                const APP_HTML = htmlDoc.substring(
                  htmlDoc.indexOf('<body>') + 6,
                  htmlDoc.indexOf('</body>')
                );

                // Strip out Styles / Meta-tags / Title
                const STYLES = [];
                const SCRIPTS = [];
                const META = [];
                const LINKS = [];
                let TITLE = '';

                //let STYLES_STRING = htmlDoc.substring(
                  //htmlDoc.indexOf('<style ng-transition'),
                  //htmlDoc.lastIndexOf('</style>') + 8
                //);
              let STYLES_STRING: string = htmlDoc.indexOf('<style ng-transition') > -1
                                    ? htmlDoc.substring(
                                        htmlDoc.indexOf('<style ng-transition'),
                                        htmlDoc.lastIndexOf('</style>') + 8)
                                    : null;
                // STYLES_STRING = STYLES_STRING.replace(/\s/g, '').replace('<styleng-transition', '<style ng-transition');

                const HEAD = AST_DOCUMENT.head;

                let count = 0;

                for (let i = 0; i < HEAD.children.length; i++) {
                  let element = HEAD.children[i];

                  if (element.name === 'title') {
                    TITLE = element.children[0].data;
//.........这里部分代码省略.........

export default createServerRenderer(params => {
    const providers = [
        { provide: INITIAL_CONFIG, useValue: { document: '<app></app>', url: params.url } },
        { provide: 'ORIGIN_URL', useValue: params.origin }
    ];

    return platformDynamicServer(providers).bootstrapModule(AppModule).then(moduleRef => {
        const appRef = moduleRef.injector.get(ApplicationRef);
        const state = moduleRef.injector.get(PlatformState);
        const zone = moduleRef.injector.get(NgZone);
        
        return new Promise<RenderResult>((resolve, reject) => {
            zone.onError.subscribe(errorInfo => reject(errorInfo));
            appRef.isStable.first(isStable => isStable).subscribe(() => {
                // Because 'onStable' fires before 'onError', we have to delay slightly before
                // completing the request in case there's an error to report
                setImmediate(() => {
                    resolve({
                        html: state.renderToString()
                    });
                    moduleRef.destroy();
                });
            });
        });
        
        // Example of accessing arguments passed from the Tag Helper
        /*
        return new Promise<RenderResult>((resolve, reject) => {
            const result = `<h1>Hello, ${params.data.userName}</h1>`;

            zone.onError.subscribe(errorInfo => reject(errorInfo));
            appRef.isStable.first(isStable => isStable).subscribe(() => {
                // Because 'onStable' fires before 'onError', we have to delay slightly before
                // completing the request in case there's an error to report
                setImmediate(() => {
                    resolve({
                        html: result
                    });
                    moduleRef.destroy();
                });
            });
        });
        */

        // Example of attaching property to browser's "window" object
        /*
        return new Promise<RenderResult>((resolve, reject) => {
            const result = `<h1>Hello, ${params.data.userName}</h1>`;

            zone.onError.subscribe(errorInfo => reject(errorInfo));
            appRef.isStable.first(isStable => isStable).subscribe(() => {
                // Because 'onStable' fires before 'onError', we have to delay slightly before
                // completing the request in case there's an error to report
                setImmediate(() => {
                    resolve({
                        html: result,
                        globals: {
                            postList: [
                                'Introduction to ASP.NET Core',
                                'Making apps with Angular and ASP.NET Core'
                            ]
                        }
                    });
                    moduleRef.destroy();
                });
            });
        });
        */
    });
});

  WebAppInternals.registerBoilerplateDataCallback('angular', async (request, data) => {

    let document,
      platformRef: PlatformRef;
    // Handle Angular's error, but do not prevent client bootstrap
    try {


      document = `
        <html>
          <head>
              <base href="/">
          </head>
          <body>
              <app></app>
          </body>
        </html>
      `;

      // Integrate Angular's router with Meteor
      const url = request.url;

      // Get rendered document
      platformRef = platformDynamicServer([
        {
          provide: INITIAL_CONFIG,
          useValue: {
            // Initial document
            document,
            url
          }
        }
      ]);

      const appModuleRef = await platformRef.bootstrapModule(ServerAppModule, {
        ngZone: 'noop',
        providers: [
          {
            provide: ResourceLoader,
            useValue: {
              get: Assets.getText
            },
            deps: []
          }
        ]
      });

      const applicationRef: ApplicationRef = appModuleRef.injector.get(ApplicationRef);

      await applicationRef.isStable.pipe(
        first(isStable => isStable == true)
      ).toPromise();

      applicationRef.tick();

      // Run any BEFORE_APP_SERIALIZED callbacks just before rendering to string.
      const callbacks = appModuleRef.injector.get(BEFORE_APP_SERIALIZED, null);
      if (callbacks) {
        for (const callback of callbacks) {
          try {
            callback();
          } catch (e) {
            // Ignore exceptions.
            console.warn('Ignoring BEFORE_APP_SERIALIZED Exception: ', e);
          }
        }
      }

      const platformState: PlatformState = appModuleRef.injector.get(PlatformState);

      document = platformState.renderToString();

    } catch (e) {

      // Write errors to console
      console.error('Angular SSR Error: ' + e.stack || e);

    } finally {

      //Make sure platform is destroyed before rendering

      if (platformRef) {
        platformRef.destroy();
      }
      const head = HEAD_REGEX.exec(document)[1];
      data.dynamicHead = head;
      const body = BODY_REGEX.exec(document)[1];
      data.dynamicBody = body;

    }
  })