Version: 5.x

single-spa-angular

The single-spa-angular project is overseen by the single-spa core team, but largely maintained by the community using it. This is because the single-spa core team is stronger in other frameworks and often doesn’t have the expertise to fix bugs in a timely manner. There are a few community members who help us actively maintain the project, which we greatly appreciate. If you have Angular experience, we’d appreciate your help in maintaining the repo. To do so, set up notifications by watching the single-spa-angular Github repository. Also, please join the #maintainers and #angular channels in Slack.

single-spa-angular is a library for creating Angular microfrontends.

Each microfrontend (single-spa application) is an Angular CLI project that can use its own version of Angular and be deployed separately from any other. They all come together into a single web page where one or more single-spa applications is active at any time.

The documentation here is extensive, so use the sidenav on the right. 👉👉👉

Join the #angular channel in single-spa’s Slack workspace.

https://coexisting-angular-microfrontends.surge.sh

https://github.com/joeldenning/coexisting-angular-microfrontends

For instructions on how to test this locally before creating a pull request, see the Contributing docs.

AngularJS is supported by single-spa-angularjs, instead of single-spa-angular. See AngularJS docs.

Angular 2 is supported by single-spa-angular@3.

The single-spa-angular schematics are not supported by Angular 2, so you’ll have to follow the steps for manual installation. The single-spa helpers work with Angular 2.

Angular 3 never existed.

Angular 4 is supported by single-spa-angular@3.

The single-spa-angular schematics are not supported by Angular 4, so you’ll have to follow the steps for manual installation. The single-spa helpers work with Angular 4.

Angular 5 is supported by single-spa-angular@3.

The single-spa-angular schematics are not supported by Angular 5, so you’ll have to follow the steps for manual installation. The single-spa helpers work with Angular 5.

Angular 6 is supported by single-spa-angular@3.

The single-spa-angular schematics are not supported by Angular 6, so you’ll have to follow the steps for manual installation. The single-spa helpers work with Angular 6.

Angular 7 is supported by single-spa-angular@3.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 7. Follow the Angular CLI instructions.

Note that the schematics for Angular 7 use an Angular Builder that is no longer used in the Angular 8 schematics.

Angular 8 is supported by single-spa-angular@3.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 8. Follow the Angular CLI instructions.

Note that the schematics for Angular 8 do not use the custom Angular builder, but instead use @angular-builders/custom-webpack.

Angular 9 is supported by single-spa-angular@4.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 9. Follow the Angular CLI instructions.

Note that the schematics for Angular 9 do not use the custom Angular builder, but instead use @angular-builders/custom-webpack.

Angular 10 is supported by single-spa-angular@4.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 10. Follow the Angular CLI instructions.

Note that the schematics for Angular 10 do not use the custom Angular builder, but instead use @angular-builders/custom-webpack.

Angular 11 is supported by single-spa-angular@4.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 11. Follow the Angular CLI instructions.

Note that the schematics for Angular 11 do not use the custom Angular builder, but instead use @angular-builders/custom-webpack.

Angular 12 is supported by single-spa-angular@5.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 12. Follow the Angular CLI instructions.

Angular 13 is supported by single-spa-angular@6.

Both the single-spa-angular schematics and the single-spa helpers work with Angular 13. Follow the Angular CLI instructions.

You may use Angular CLI and single-spa together with any version of Angular. However, the Angular CLI schematics only work if you’re using Angular >= 7. If you’re using an older version of Angular, follow the manual installation instructions.

First, create an angular application. This requires installing Angular CLI. Note that the --prefix is important so that when you have multiple angular applications their component selectors won’t have the same names.

  1. ng new my-app --routing --prefix my-app
  2. cd my-app

In the root of your Angular CLI application run the following:

  1. ng add single-spa-angular

Angular schematics are processed when you run ng add single-spa-angular.

The single-spa-angular schematics perform the following tasks:

  • Install single-spa-angular.
  • Generate a main.single-spa.ts in your project src/.
  • Generate single-spa-props.ts in src/single-spa/
  • Generate asset-url.ts in src/single-spa/
  • Generate an EmptyRouteComponent in src/app/empty-route/, to be used in app-routing.module.ts.
  • Add an npm script npm run build:single-spa.
  • Add an npm script npm run serve:single-spa.
  • For Angular 7 only, create a new entry in the project’s architect called single-spa, which is a preconfigured Angular Builder.

Now you must configure routes. Then you can serve and build.

The manual installation instructions should be used if you are not using Angular CLI or if you are using Angular 6 or older.

  1. npm install --save single-spa-angular

Since the single-spa-angular schematics didn’t run, you’ll need to make the following changes:

  1. Create all of the files that would have been created by the schematic. See schematics files. Be sure to get the files in the subdirectories, too.
  2. Add build:single-spa and serve:single-spa to the scripts in your package.json. See addNPMScripts function.
  3. Use the angular builder, as described in the next section.

Note that this only applies to Angular versions pre Angular 8. Up until Angular 8, we maintained an angular builder that allowed us to control the webpack config, but since Angular 8 we use @angular-builders/custom-webpack instead. See documentation for using the custom webpack builder with single-spa-angular and Angular 8+.

If you installed this library with Angular 7 using the Angular Schematic, this is already configured and you don’t need to change it. Otherwise, you might need to do this manually.

If you don’t use Angular CLI, skip this section.

To build your Angular CLI application as a single-spa app do the following.

  • Open angular.json
  • Locate the project you wish to update.
  • Navigate to the architect > build property.
  • Set the builder property to single-spa-angular:build.
  • Run ng build and verify your dist contains one asset, main.js.

Example Configuration:

  1. {
  2.   "architect": {
  3.     "build": {
  4.       "builder": "single-spa-angular:build",
  5.       "options": {
  6.         "libraryName": "hello"
  7.       }
  8.     },
  9.     "serve": {
  10.       "builder": "single-spa-angular:dev-server",
  11.       "options": {}
  12.     }
  13.   }
  14. }

Configuration options are provided to the architect.build.options section of your angular.json.

NameDescriptionDefault Value
libraryName(optional) Specify the name of the moduleAngular CLI project name
libraryTarget(optional) The type of library to build see available options“UMD”
singleSpaWebpackConfigPath(optional) Path to partial webpack config to be merged with angular’s config. Example: extra-webpack.config.jsundefined

Configuration options are provided to the architect.serve.options section of your angular.json.

NameDescriptionDefault Value
singleSpaWebpackConfigPath(optional) Path to partial webpack config to be merged with angular’s config. Example: extra-webpack.config.jsundefined

Starting with Angular 8, single-spa-angular’s schematics install and use @angular-builders/custom-webpack to modify the webpack config. The schematics also create an extra-webpack.config.js file in your project where you can modify the configuration further.

The extra-webpack.config.js file should include the following:

  1. const singleSpaAngularWebpack = require('single-spa-angular/lib/webpack')
  2.   .default;
  4. module.exports = (config, options) => {
  5.   const singleSpaWebpackConfig = singleSpaAngularWebpack(config, options);
  7.   // Feel free to modify this webpack config however you'd like to
  8.   return singleSpaWebpackConfig;
  9. };

Older versions of single-spa-angular@3 and single-spa-angular@4 created extra-webpack.config.js files that did not pass options into singleSpaAngularWebpack. When you upgrade to newer versions, you’ll need to pass in the options as shown above.

In addition to modifying the webpack config directly, you may alter some of single-spa-angular’s behavior by changing the angular.json. Configuration options are provided to the architect.build.options.customWebpackConfig section of your angular.json.

NameDescriptionDefault Value
path(required) Path to the the above extra-webpack.config.js file.N/A
libraryName(optional) Specify the name of the moduleAngular CLI project name
libraryTarget(optional) The type of library to build see available options“UMD”
excludeAngularDependencies(optional) Excludes Angular dependencies from the bundle by adding them to Webpack externalsfalse

If you’re using SystemJS, you may want to consider changing the webpack output.libraryTarget to be "system", for better interop with SystemJS.

To get single-spa working, you’ll need to manually modify a few files.

  1. Add providers: [{ provide: APP_BASE_HREF, useValue: '/' }] to app-routing.module.ts. See angular docs for more details about APP_BASE_HREF.
  2. Add { path: '**', component: EmptyRouteComponent } to your app-routing.module.ts routes. The EmptyRouteComponent is part of the single-spa-angular schematics. This route makes sure that when single-spa is transitioning between routes that your Angular application doesn’t try to show a 404 page or throw an error. See angular docs for more details about routes.
  3. Add a declaration for EmptyRouteComponent in app.module.ts. See angular docs for more details about app.module.ts.
Angular - 图1caution

APP_BASE_HREF should have the same value that the used url for mount the Angular app defined in the single-spa root application. But doing this causes strange behaviours in Angular Router when navigate between registered apps.

In order to avoid this is recommended using ‘/‘ as APP_BASE_HREF and repeat the url prefix for your Angular app in every route component and router links. If you set /angular in your Angular app activity function for mount when the url starts with this value you’ll have to add /angular prefix in all links.

You can see several discussions about this issue in single-spa-angular GitHub repo: Router not working without APP_BASE_HREF and How to handle router links between different single-spa application subrouters

To link between applications, simply use routerLink like normal.

  1. <a routerLink="/other-app">
  2.   Link to other app
  3. </a>

Nested routes work exactly the same as they normally do. To create a nested route, add it to your app-routing.module.ts. To link to a nested route, use routerLink the same way you normally do.

  1. <a routerLink="/my-app/nested-route">
  2.   Link to nested route
  3. </a>

You need to firstly enable hash mode in root-config.

If you are using layout html with single-spa-router, add mode="hash"

  1. <single-spa-router mode="hash">
  2.   ...
  3. </single-spa-router>

If you are registering each route manually, use location.hash

  1. registerApplication({
  2.   name: '@orgName/app1',
  3.   app: () => System.import('@orgName/app1'),
  4.   activeWhen: location => location.hash.startsWith('#/app1'),
  5. });

Then, enable hash mode in your routing module of angular micro frontend application.

  1. @NgModule({
  2.     imports: [RouterModule.forRoot(routes, {useHash: true})],
  3.     exports: [RouterModule]
  4. })

Run the following:

  1. npm run serve:single-spa

This will not open up an HTML file, since single-spa applications all share one html file. Instead, go to http://single-spa-playground.org and follow the instructions there to verify everything is working and for instructions on creating the shared HTML file.

Run npm run build:single-spa, which will create a dist directory with your compiled code.

In order for the webpack public path to be correctly set for your assets, you should use Angular CLI’s --deploy-url option. For more information, see this Stack Overflow answer which shows a few options for how to do that.

“single-spa helpers” refers to the in-browser portion of single-spa-angular. The helpers are used by all versions of Angular and regardless of whether you are using Angular CLI or not. This is the core of the single-spa-angular library that makes it possible for Angular applications to bootstrap, mount, and unmount. See single-spa lifecycles for more information.

​ Migrating from 3.x to 4.x requires only few API updates. ​

​

  1. npm i --save single-spa-angular@4.0.0
  2. # Or if you're using yarn
  3. yarn add single-spa-angular@4.0.0

​

​ single-spa-angular doesn’t have a default export anymore, instead you have to import a named singleSpaAngular function. Given the following code: ​

  1. import singleSpaAngular from 'single-spa-angular'; // single-spa-angular@3.x
  2. import { singleSpaAngular } from 'single-spa-angular'; // single-spa-angular@4.x

​ Also, if your application uses routing then you have to import the getSingleSpaExtraProviders function. Let’s look at the following example, this is how it was in single-spa-angular@3.x: ​

  1. import { NgZone } from '@angular/core';
  2. import { Router, NavigationStart } from '@angular/router';
  3. import singleSpaAngular, { getSingleSpaExtraProviders } from 'single-spa-angular';
  4. ​
  5. const lifecycles = singleSpaAngular({
  6.   bootstrapFunction: singleSpaProps => {
  7.     singleSpaPropsSubject.next(singleSpaProps);
  8.     return platformBrowserDynamic(getSingleSpaExtraProviders()).bootstrapModule(AppModule);
  9.   },
  10.   template: '<app-root />',
  11.   Router,
  12.   NavigationStart,
  13.   NgZone,
  14. });

​ And this is how it should be in single-spa-angular@4.x: ​

  1. import { NgZone } from '@angular/core';
  2. import { Router, NavigationStart } from '@angular/router';
  3. import { singleSpaAngular, getSingleSpaExtraProviders } from 'single-spa-angular';
  4. ​
  5. const lifecycles = singleSpaAngular({
  6.   bootstrapFunction: singleSpaProps => {
  7.     singleSpaPropsSubject.next(singleSpaProps);
  8.     return platformBrowserDynamic(getSingleSpaExtraProviders()).bootstrapModule(AppModule);
  9.   },
  10.   template: '<app-root />',
  11.   Router,
  12.   NavigationStart,
  13.   NgZone,
  14. });
  1. import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
  2. import { NgZone } from '@angular/core';
  3. import { Router, NavigationStart } from '@angular/router';
  4. import {
  5.   singleSpaAngular,
  6.   getSingleSpaExtraProviders,
  7. } from 'single-spa-angular';
  9. import { AppModule } from './app/app.module';
  11. const lifecycles = singleSpaAngular({
  12.   bootstrapFunction: singleSpaProps => {
  13.     return platformBrowserDynamic(getSingleSpaExtraProviders()).bootstrapModule(
  14.       AppModule,
  15.     );
  16.   },
  17.   template: '<app-root />',
  18.   Router,
  19.   NavigationStart,
  20.   NgZone,
  21. });
  23. export const bootstrap = lifecycles.bootstrap;
  24. export const mount = lifecycles.mount;
  25. export const unmount = lifecycles.unmount;

See this schematic file for a good example of how to use the single-spa helpers.

Options are passed to single-spa-angular via the opts parameter when calling singleSpaAngular(opts). This happens inside of your main.single-spa.ts file.

The following options are available:

  • bootstrapFunction: (required) A function that is given custom props as an argument and returns a promise that resolves with a resolved Angular module that is bootstrapped. Usually, your implementation will look like this: bootstrapFunction: (customProps) => platformBrowserDynamic().bootstrapModule(). See custom props documentation for more info on the argument passed to the function.
  • template: (required) An HTML string that will be put into the DOM Element returned by domElementGetter. This template can be anything, but it is recommended that you keeping it simple by making it only one Angular component. For example, <app-root /> is recommended, but <div><app-root /><span>Hello</span><another-component /></div> is allowed. Note that innerHTML is used to put the template onto the DOM. Also note that when using multiple angular applications simultaneously, you will want to make sure that the component selectors provided are unique to avoid collisions. When migrating to single-spa, this template is what is inside of your index.html file’s <body> element.
  • Router: (optional) The angular router class. This is required when you are using @angular/router.
  • AnimationModule: (optional) The animation module class. This is required when you are using BrowserAnimationsModule. Example way to import this: import { eAnimationEngine as AnimationModule } from '@angular/animations/browser';. See Issue 48 for more details. Note that AnimationModule is no longer needed in Angular 12, so this option can be ignored in Angular >= 12.
  • domElementGetter: (optional) A function that takes in no arguments and returns a DOMElement. This dom element is where the Angular application will be bootstrapped, mounted, and unmounted. It’s recommended to omit this and let single-spa-angular’s defaults create and use a container div.

ZoneJS is the library that Angular uses for change detection. You absolutely must have exactly one instance of the ZoneJS library on the page. ZoneJS will throw errors if you have more than one instance of ZoneJS on the page.

The preferred way to ensure only one instance of ZoneJS is loaded on your page is with a script tag in your root-config’s HTML file. You should load ZoneJS upfront a single time, before loading SystemJS or any of your microfrontends.

  1. <script src="https://cdn.jsdelivr.net/npm/zone.js@0.10.3/dist/zone.min.js"></script>

Note that having only one instance of ZoneJS is different than having only one zone within that instance. single-spa-angular automatically will ensure that each of your Angular applications has its own isolated, separate zone.

When you have multiple apps running side by side, you’ll need to make sure that their component selectors are unique. When creating a new project, you can have angular-cli do this for you by passing in the --prefix option:

  1. ng new --prefix app2

If you did not use the --prefix option, you should set the prefix manually:

  1. For an application called app2, add "prefix": "app2" to projects.app2 inside of the angular.json.
  2. Go to app.component.ts. Modify selector to be app2-root.
  3. Go to main.single-spa.ts. Modify template to be <app2-root>.

Additionally, make sure that reflect-metadata is only imported once in the root application and is not imported again in the child applications. Otherwise, you might see an No NgModule metadata found error. See issue thread for more details.

Custom props are a way of passing auth or other data to your single-spa applications. The custom props are available inside of the bootstrapFunction passed to singleSpaAngular(). Additionally, if you use the angular cli schematic, you may subscribe to the singleSpaPropsSubject in your component, as shown below:

  1. // An example showing where you get access to the single-spa props:
  2. import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
  3. import { singleSpaAngular } from 'single-spa-angular';
  5. const lifecycles = singleSpaAngular({
  6.   bootstrapFunction(singleSpaProps) {
  7.     // Here are the custom props
  8.     console.log(singleSpaProps);
  9.     return platformBrowserDynamic().bootstrapModule(AppModule);
  10.   },
  11.   // add the other options to singleSpaAngular, too. See "Basic usage" for more info
  12. });
  1. // If you're using the singleSpaPropsSubject generated by the single-spa-angular schematics,
  2. // here's an example component that uses the custom props
  3. import { Component, OnInit, OnDestroy } from '@angular/core';
  4. import { Subscription } from 'rxjs';
  5. import {
  6.   singleSpaPropsSubject,
  7.   SingleSpaProps,
  8. } from 'src/single-spa/single-spa-props';
  10. @Component({
  11.   selector: 'app-root',
  12.   templateUrl: './app.component.html',
  13.   styleUrls: ['./app.component.css'],
  14. })
  15. export class AppComponent implements OnInit, OnDestroy {
  16.   singleSpaProps: SingleSpaProps;
  17.   subscription: Subscription;
  19.   ngOnInit(): void {
  20.     this.subscription = singleSpaPropsSubject.subscribe(
  21.       props => (this.singleSpaProps = props),
  22.     );
  23.   }
  25.   ngOnDestroy(): void {
  26.     this.subscription.unsubscribe();
  27.   }
  29.   // OR if you don't need to access `singleSpaProps` inside the component
  30.   // then create `Observable` property and use it in template with `async` pipe.
  31.   singleSpaProps$ = singleSpaPropsSubject.asObservable();
  32. }

Angular assets are handled differently within single-spa than within other Angular applications. The schematics file called asset-url.ts helps you do load assets in a way that works both ways.

This won’t work

  1. // Doesn't work with single-spa
  2. const imageUrl = '/assets/yoshi.png';

Do this instead

  1. import { assetUrl } from 'src/single-spa/asset-url';
  3. // Works great with single-spa
  4. const imageUrl = assetUrl('yoshi.png');

Add the asset url to your component’s class and reference it from the template. See here and here.

Create an Angular Pipe that lets you calculate the asset url inside of an HTML template:

  1. import { Pipe, PipeTransform } from '@angular/core';
  2. import { assetUrl } from 'src/single-spa/public-path';
  4. @Pipe({ name: 'assetUrl' })
  5. export class AssetUrlPipe implements PipeTransform {
  6.   transform(value: string): string {
  7.     return assetUrl(value);
  8.   }
  9. }

Then use it in your template:

  1. <img [src]="'yoshi.png' | assetUrl" />

Scripts in your angular.json are not loaded by single-spa. This is because single-spa applications have to all share an HTML file. (read more). You can remove the scripts from your angular.json because they have no impact on your single-spa build.

Add the script tags directly into your root HTML file. This way is easiest. The downside is that all of the scripts get loaded even for routes that don’t need them. However, that is generally okay and this is the preferred way to do it.

If you want the scripts to only be loaded when needed, you can add a custom bootstrap lifecycle to your code.

Note that lazy loading these scripts can actually be worse for performance if you always need them, since they will start downloading later than if you put them right into the root HTML file.

  1. // main.single-spa.ts
  3. // Modify the bootstrap function like so
  4. export const bootstrap = [
  5.   () =>
  6.     Promise.all([
  7.       loadScript(
  8.         'https://cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js',
  9.       ),
  10.       loadScript(
  11.         'https://cdnjs.cloudflare.com/ajax/libs/datepicker/0.6.5/datepicker.min.js',
  12.       ),
  13.     ]),
  14.   lifecycles.bootstrap,
  15. ];
  17. function loadScript(url: string) {
  18.   return new Promise((resolve, reject) => {
  19.     const script = document.createElement('script');
  20.     script.src = url;
  22.     function onLoad() {
  23.       resolve();
  24.       cleanup();
  25.     }
  27.     function onError(event: Event) {
  28.       reject(event);
  29.       cleanup();
  30.     }
  32.     function cleanup() {
  33.       script.removeEventListener('load', onLoad);
  34.       script.removeEventListener('error', onError);
  35.     }
  37.     script.addEventListener('load', onLoad);
  38.     script.addEventListener('error', onError);
  39.     document.head.appendChild(script);
  40.   });
  41. }

Styles in your angular.json will automatically be loaded by single-spa-angular’s webpack config, without you having to configure anything.

Your component styles will also be loaded like normal without you having to configure anything.

rebaseRootRelativeCssUrls

The rebaseRootRelativeCssUrls option allows you to keep your css referencing asset urls, which will be rewritten to respect the webpack public path:

  1. .body-row {
  2.   background: url('/assets/images/person.jpg') no-repeat right bottom;
  3. }

To do this, you may change your angular.json or run ng build --rebaseRootRelativeCssUrls. In the angular.json file, you should modify architect > build > options and update the property rebaseRootRelativeCssUrls to be true.

Now inside the assets attribute (which is an array) you should add a slash “/“ to the value of the “output” attribute which outputs its external styles (this is optional). Example:

  1. {
  2.   "options": {
  3.     "rebaseRootRelativeCssUrls": true,
  4.     "assets": [
  5.       "src/favicon.ico",
  6.       "src/assets",
  7.       {
  8.         "glob": "**/*",
  9.         "input": "node_modules/@material/dist/collection/assets",
  10.         "output": "/assets"
  11.       }
  12.     ]
  13.   }
  14. }

Polyfills in your angular.json are JavaScript code that make your project work in older browsers, such as IE11.

The polyfills that you specify in your angular.json file will not be loaded automatically. This is because we should only load polyfills once in the root HTML file, instead of once per application.

To load polyfills, you’ll need to follow the instructions in the Angular documentation for non-CLI users. Even if you are using Angular CLI, you will need to follow those instructions, since your single-spa root HTML file is not using Angular CLI and that’s where the polyfills need to go.

If you’re looking for a quick one-liner, try adding this line near the top of your index.html.

  1. <script src="https://unpkg.com/core-js-bundle/minified.js"></script>

To correct the error It looks like your application or one of its dependencies is using i18n.

Install @angular/localize in your root-config module

  1. npm i @angular/localize

Add following import to your root-config.js

  1. import '@angular/localize/init';

If you need to support IE11 or older, do the following:

Full example commit to get IE11 support

Sharing one or more instances of Angular between microfrontends provides the following benefits:

  1. Performance improvement, due to reduced amount of javascript to load.
  2. Cross-microfrontend imports of angular components are possible. (Without a shared instance of Angular, you can still use cross-microfrontend imports of single-spa parcels)

There are two techniques for sharing Angular: SystemJS in-browser modules and Module Federation.

The below guide uses SystemJS for sharing dependencies.

⚠️ Angular 13 has few breaking changes. It dropped View Engine support, and this means there’s a single template compiler right now (Ivy). They also introduced changes to the Angular Package Format. UMD bundles are no longer generated when building libraries. The ng-packagr now emits only ES2015 and ES2020 bundles. See this article for more info: https://blog.angular.io/angular-v13-is-now-available-cce66f7bc296.

You can use the following esm-bundle packages, which provide Ivy-compatible versions that can be shared via SystemJS:

The single-spa-angular is also available in SystemJS format:

Let’s imagine that we have 2 Angular applications and the root-config application. Angular applications want to share dependencies. First of all, we need to exclude Angular dependencies from their bundles, this can be done via Webpack externals property, but single-spa-angular@6.2.0+ has an option that will exclude rxjs, @angular/* and single-spa-angular/* packages:

  1. "build": {
  2.   "builder": "@angular-builders/custom-webpack:browser",
  3.   "options": {
  4.     "customWebpackConfig": {
  5.       "libraryTarget": "system",
  6.       "excludeAngularDependencies": true,
  7.       "path": "..."
  8.     }
  9.   }
  10. }

Note that we set the libraryTarget to system and excludeAngularDependencies to true.

Next we need to replace enableProdMode from @angular/core with enableProdMode from single-spa-angular in our applications:

  1. import { enableProdMode } from 'single-spa-angular';
  3. if (environment.production) {
  4.   enableProdMode();
  5. }

This is because Angular’s enableProdMode throws an error when it’s called multiple times, but it will be called multiple times when dependencies are shared. single-spa-angular calls the original enableProdMode but swallows the error.

We also have to consider the platform injector that will be re-used between applications. Angular creates a platform injector when it bootstraps an application; it creates it only once and then re-uses it. Each Angular application has its own platform injector when dependencies are NOT shared and will have a single one when dependencies are shared. This means that providedIn: 'platform' services will be a part of the single injector and will be shared between applications.

single-spa-angular exports the getSingleSpaExtraProviders function that adds SingleSpaPlatformLocation to the platform injector. This function should be called in each application (even if that application doesn’t use routing). We also have to share the single-spa-angular package because applications should reference the same SingleSpaPlatformLocation class. Assume that app1 is created earlier than app2, app1 doesn’t call getSingleSpaExtraProviders() when bootstrapping the root module, but app2 does. The platform injector is created eagerly when the platformBrowser() is called for the first time. The app2 will then try to retrieve the SingleSpaPlatformLocation, but there’s no such injectee within the platform injector since app1 didn’t declare this dependency.

The root-config should have a SystemJS import map with all of the required packages:

  1. {
  2.   "imports": {
  3.     "app1": "http://localhost:4200/main.js",
  4.     "app2": "http://localhost:4201/main.js",
  6.     "single-spa": "https://cdnjs.cloudflare.com/ajax/libs/single-spa/5.9.3/system/single-spa.dev.js",
  7.     "rxjs": "https://cdn.jsdelivr.net/npm/@esm-bundle/rxjs/system/es2015/rxjs.min.js",
  8.     "rxjs/operators": "https://cdn.jsdelivr.net/npm/@esm-bundle/rxjs/system/es2015/rxjs-operators.min.js",
  9.     "@angular/compiler": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__compiler/system/es2020/ivy/angular-compiler.js",
  10.     "@angular/core": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__core/system/es2020/ivy/angular-core.js",
  11.     "@angular/common": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__common/system/es2020/ivy/angular-common.js",
  12.     "@angular/common/http": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__common/system/es2020/ivy/angular-http.js",
  13.     "@angular/animations": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__animations/system/es2020/ivy/angular-animations.js",
  14.     "@angular/animations/browser": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__animations/system/es2020/ivy/angular-browser.js",
  15.     "@angular/platform-browser": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__platform-browser/system/es2020/ivy/angular-platform-browser.js",
  16.     "@angular/platform-browser/animations": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__platform-browser/system/es2020/ivy/angular-animations.js",
  17.     "@angular/platform-browser-dynamic": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__platform-browser-dynamic/system/es2020/ivy/angular-platform-browser-dynamic.js",
  18.     "@angular/router": "https://cdn.jsdelivr.net/npm/@esm-bundle/angular__router/system/es2020/ivy/angular-router.js",
  19.     "single-spa-angular/internals": "https://cdn.jsdelivr.net/npm/@esm-bundle/single-spa-angular@6.2.0/system/es2020/ivy/angular-single-spa-angular-internals.js",
  20.     "single-spa-angular": "https://cdn.jsdelivr.net/npm/@esm-bundle/single-spa-angular@6.2.0/system/es2020/ivy/angular-single-spa-angular.js"
  21.   }
  22. }

Production bundles also don’t use @angular/compiler and @angular/platform-browser-dynamic packages. You would want to use minified packages when the root-config is built in production mode. One approach could be to use if-else conditions within the root-config .ejs template:

  1. <% if (htmlWebpackPlugin.options.isDevelopment) { %>
  2. <script type="systemjs-importmap">
  3.   {
  4.     "imports": {
  5.       "@angular/compiler": "..."
  6.     }
  7.   }
  8. </script>
  9. <%} else { %>
  10. <script type="systemjs-importmap">
  11.   {
  12.     "imports": {
  13.       "@angular/core": "angular-core.min.js"
  14.     }
  15.   }
  16. </script>
  17. <% } %>

Note: the isDevelopment can be provided when creating the HtmlWebpackPlugin:

  1. const HtmlWebpackPlugin = require('html-webpack-plugin');
  3. module.exports = (env, { mode }) => {
  4.   const isDevelopment = mode !== 'production';
  6.   return {
  7.     plugins: [
  8.       new HtmlWebpackPlugin({
  9.         template: '...',
  10.         isDevelopment,
  11.       }),
  12.     ],
  13.   };
  14. };

The mode will equal production when you run webpack --mode production.

The root-config then can load single-spa, register applications and start the single-spa in order for applications to be mounted:

  1. System.import('single-spa').then(({ registerApplication, start }) => {
  2.   registerApplication({
  3.     name: 'app1',
  4.     app: () => System.import('app1'),
  5.     activeWhen: location => location.pathname.startsWith('/app1'),
  6.   });
  8.   registerApplication({
  9.     name: 'app2',
  10.     app: () => System.import('app2'),
  11.     activeWhen: location => location.pathname.startsWith('/app2'),
  12.   });
  14.   start();
  15. });
Angular - 图2info

This feature is available starting from single-spa-angular@4.4.0. You also may need to become familiar with Angular Elements documentation.

Let’s start with installing the @angular/elements:

  1. npm i --save @angular/elements
  2. # Or if you're using yarn
  3. yarn add @angular/elements

The next step is to edit main.single-spa.ts:

  1. import { enableProdMode } from '@angular/core';
  2. import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
  3. import { singleSpaAngularElements } from 'single-spa-angular/elements';
  5. import { AppModule } from './app/app.module';
  6. import { environment } from './environments/environment';
  8. if (environment.production) {
  9.   enableProdMode();
  10. }
  12. const lifecycles = singleSpaAngularElements({
  13.   template: '<app-custom-element />',
  14.   // We can actually not rely on the `zone.js` library, our custom element
  15.   // will behave itself as a zone-less application.
  16.   bootstrapFunction: () =>
  17.     platformBrowserDynamic().bootstrapModule(AppModule, { ngZone: 'noop' }),
  18. });
  20. export const bootstrap = lifecycles.bootstrap;
  21. export const mount = lifecycles.mount;
  22. export const unmount = lifecycles.unmount;

Note that the app-custom-element selector will be used when defining our custom element.

After that, you’ll have to edit app.module.ts and define a custom tag:

  1. import { NgModule, Injector, DoBootstrap } from '@angular/core';
  2. import { BrowserModule } from '@angular/platform-browser';
  3. import { createCustomElement } from '@angular/elements';
  5. import { AppComponent } from './app.component';
  7. @NgModule({
  8.   imports: [BrowserModule],
  9.   declarations: [AppComponent],
  10. })
  11. export class AppModule implements DoBootstrap {
  12.   constructor(private injector: Injector) {}
  14.   ngDoBootstrap(): void {
  15.     customElements.define(
  16.       // This tag we've have provided in `options.template` when called `singleSpaAngularElements`.
  17.       'app-custom-element',
  18.       createCustomElement(AppComponent, { injector: this.injector }),
  19.     );
  20.   }
  21. }

The following options are available to be passed when calling singleSpaAngularElements:

  • bootstrapFunction (required)
  • template (required)
  • domElementGetter (optional)

See options for detailed explanation.

We encourage you to get familiar with the documentation, namely Parcels overview and Parcels API. This documentation will give you a basic understanding of what parcels are.

Additionally, single-spa-angular provides a <parcel> component to make using framework agnostic single-spa parcels easier. This allows you to put the parcel into your component’s template, instead of calling mountRootParcel() by yourselves.

single-spa-angular/parcel package exports the ParcelModule which exports the <parcel> component:

  1. // Inside of src/app/app.module.ts
  2. import { BrowserModule } from '@angular/platform-browser';
  3. import { NgModule } from '@angular/core';
  4. import { ParcelModule } from 'single-spa-angular/parcel';
  6. import { AppComponent } from './app.component';
  8. @NgModule({
  9.   imports: [BrowserModule, ParcelModule],
  10.   declarations: [AppComponent],
  11.   bootstrap: [AppComponent],
  12. })
  13. export class AppModule {}

The example below shows how you can render React parcels:

  1. // Inside of src/app/app.component.ts
  2. import { ChangeDetectionStrategy, Component } from '@angular/core';
  3. import { mountRootParcel } from 'single-spa';
  5. import { config } from './ReactWidget/ReactWidget';
  7. @Component({
  8.   selector: 'app-root',
  9.   template:
  10.     '<parcel [config]="config" [mountParcel]="mountRootParcel"></parcel>',
  11.   changeDetection: ChangeDetectionStrategy.OnPush,
  12. })
  13. export class AppComponent {
  14.   config = config;
  15.   mountRootParcel = mountRootParcel;
  16. }

For React, you will need to create a file with the extension .tsx:

  1. // Inside of src/app/ReactWidget/ReactWidget.tsx
  2. import * as React from 'react';
  3. import * as ReactDOM from 'react-dom';
  4. import singleSpaReact from 'single-spa-react';
  6. const ReactWidget = () => <div>Hello from React!</div>;
  8. export const config = singleSpaReact({
  9.   React,
  10.   ReactDOM,
  11.   rootComponent: ReactWidget,
  12. });

If your code is part of an import map and you include a global reference to systemjs, you can dynamically import the code using an async method.

For example, if your import map includes the ReactComponent.

  1. {
  2.   imports: {
  3.     "@org/react-component": '/org-react-component.js'
  4.   }
  5. }

You can dynamically load the component by setting the config as an asynchronous method that fetches the component.

Since some versions of webpack use SystemJS under the hood, you’ll need to reference the global version.

  1. // Inside of src/app/app.component.ts
  2. import { ChangeDetectionStrategy, Component } from '@angular/core';
  3. import { mountRootParcel } from 'single-spa';
  5. @Component({
  6.   selector: 'app-root',
  7.   template:
  8.     '<parcel [config]="config" [mountParcel]="mountRootParcel"></parcel>',
  9.   changeDetection: ChangeDetectionStrategy.OnPush,
  10. })
  11. export class AppComponent {
  12.   async config() {
  13.     return window.System.import('@org/react-component');
  14.   }
  15.   mountRootParcel = mountRootParcel;
  16. }

You can pass any custom props to the parcel by passing an object of props using the customProps attribute.

For example, if you’re rendering a React parcel from an Angular component, you can pass a click handler from Angular into the React parcel:

  1. // Inside of src/app/ReactWidget/ReactWidget.tsx
  2. import * as React from 'react';
  3. import * as ReactDOM from 'react-dom';
  4. import singleSpaReact from 'single-spa-react';
  6. const ReactWidget = ({ handleClick }) => (
  7.   <button onClick={handleClick}>Click Me!</button>
  8. );
  10. export const parcelConfig = singleSpaReact({
  11.   React,
  12.   ReactDOM,
  13.   rootComponent: ReactWidget,
  14. });

You can pass a function (or any other value) as a custom prop. To ensure that the functions you pass to the parcel are bound with the correct javascript context, use the handleClick = () => { syntax when defining your functions.

  1. // Inside of src/app/app.component.ts
  2. import { ChangeDetectionStrategy, Component } from '@angular/core';
  3. import { mountRootParcel } from 'single-spa';
  5. import { config } from './ReactWidget/ReactWidget';
  7. @Component({
  8.   selector: 'app-root',
  9.   template:
  10.     '<parcel [config]="config" [customProps]="parcelProps" [mountParcel]="mountRootParcel"></parcel>',
  11.   changeDetection: ChangeDetectionStrategy.OnPush,
  12. })
  13. export class AppComponent {
  14.   config = config;
  15.   mountRootParcel = mountRootParcel;
  17.   handleClick = () => {
  18.     alert('Hello World');
  19.   };
  21.   parcelProps = {
  22.     handleClick = this.handleClick,
  23.   };
  24. }
Angular - 图3info

This feature is available starting from single-spa-angular@4.1.

It’s possible to develop Angular applications that don’t rely on zone.js library, these applications are called zone-less. You have to run change detection manually in zone-less applications through ApplicationRef.tick() or ChangeDetectorRef.detectChanges(). You can find more info in Angular NoopZone docs.

The point is that you do not need to load zone.js library in your root HTML file. As Angular docs mention that you should have a comprehensive knowledge of change detection to develop such applications. Let’s start by nooping zone when bootstrapping module:

  1. import { singleSpaAngular } from 'single-spa-angular';
  3. const lifecycles = singleSpaAngular({
  4.   bootstrapFunction: () =>
  5.     platformBrowserDynamic().bootstrapModule(AppModule, { ngZone: 'noop' }),
  6.   template: '<app-root />',
  7.   NgZone: 'noop',
  8. });
Angular - 图4caution

We must specify noop twice: when bootstrapping AppModule, and setting NgZone property to noop. This tells Angular and single-spa-angular that we’re not going to use zones.

Since routing is managed by single-spa and there is no zone that tells Angular that some asynchronous event has occured, then we need to tell Angular when to run change detection if routing occurs. Let’s look at the below code:

  1. import { ApplicationRef } from '@angular/core';
  2. import { Router, NavigationStart } from '@angular/router';
  3. import { singleSpaAngular } from 'single-spa-angular';
  5. const lifecycles = singleSpaAngular({
  6.   bootstrapFunction: async () => {
  7.     const ngModuleRef = await platformBrowserDynamic().bootstrapModule(
  8.       AppModule,
  9.       { ngZone: 'noop' },
  10.     );
  12.     const appRef = ngModuleRef.injector.get(ApplicationRef);
  13.     const listener = () => appRef.tick();
  14.     window.addEventListener('popstate', listener);
  16.     ngModuleRef.onDestroy(() => {
  17.       window.removeEventListener('popstate', listener);
  18.     });
  20.     return ngModuleRef;
  21.   },
  22.   template: '<app-root />',
  23.   NgZone: 'noop',
  24.   Router,
  25.   NavigationStart,
  26. });
Angular - 图5caution

single-spa-angular@4.x requires calling getSingleSpaExtraProviders function in applications that have routing. Do not call this function in zone-less application.

First of all, check out this Inter-app communication guide.

It’s possible to setup a communication between microfrontends via RxJS using cross microfrontend imports.

We can not create complex abstractions, but simply export the Subject:

  1. // Inside of @org/api
  2. import { ReplaySubject } from 'rxjs';
  3. import { User } from '@org/models';
  5. // `1` means that we want to buffer the last emitted value
  6. export const userSubject$ = new ReplaySubject<User>(1);

And then you just need to import this Subject into the microfrontend application:

  1. // Inside of @org/app1 single-spa application
  2. import { userSubject$ } from '@org/api';
  3. import { User } from '@org/models';
  5. userSubject$.subscribe(user => {
  6.   // ...
  7. });
  9. userSubject$.next(newUser);

Also, you should remember that @org/api should be an “isolated” dependency, for example the Nrwl Nx library, where each library is in the “libs” folder and you import it via TypeScript paths.

Every application that uses this library should add it to its Webpack config as an external dependency:

  1. const singleSpaAngularWebpack = require('single-spa-angular/lib/webpack')
  2.   .default;
  4. module.exports = (config, options) => {
  5.   const singleSpaWebpackConfig = singleSpaAngularWebpack(config, options);
  6.   singleSpaWebpackConfig.externals = [/^@org\/api$/];
  7.   return singleSpaWebpackConfig;
  8. };

But this library should be part of root application bundle and shared with import maps, for example:

  1. {
  2.   "imports": {
  3.     "@org/api": "http://localhost:8080/api.js"
  4.   }
  5. }

Angular - 图6Edit this page