Build micro frontends that coexist and can each be written with their own framework. This allows you to:
- Use multiple frameworks on the same page without refreshing the page (React, AngularJS, Angular, Ember, or whatever you're using)
- Write code using a new framework, without rewriting your existing app
- Lazy load code for improved initial load time.
A live demo is available and the source code for that demo is available in the single-spa-examples repository.
Also, you can check out a simple webpack starter project which is simpler and hopefully easier to get started with.
Single-spa takes inspiration from React component lifecycles by applying lifecycles to entire applications. It started out of a desire to use React + react-router instead of being forever stuck with our AngularJS + ui-router application, but now single-spa supports almost any framework coexisting with any other. Since Javascript is notorious for the short-life of its many frameworks, we decided to make it easy to use whichever frameworks you want.
Apps built with single-spa are made up of the following pieces:
- Many applications, each of which is sort of like an entire SPA itself. Applications respond to url routing events and must know how to bootstrap, mount, and unmount themselves from the DOM. The main difference between a SPA and an application is that applications must coexist together and do not each have their own html page. For example, your React or Angular applications are applications which are either active or dormant. When active, they listen to url routing events and put content on the DOM. When dormant, they do not listen to url routing events and are totally removed from the DOM.
- A single-spa-config. The single-spa-config is the html page, plus the javascript that registers applications with single-spa. Each application is registered with three things:
- A name
- A function to load the application's code
- A function that determines when the application is active/dormant.
single-spa works with es5, es6+, typescript, webpack, systemjs, gulp, grunt, bower, ember-cli, or really anything build system you can think of. You can npm install it, jspm install it, or even just use a <script> tag if you prefer. If you're not starting your application from scratch, you'll have to migrate your SPA to become a single-spa application.
single-spa works in Chrome, Firefox, Safari, IE11, and Edge.
Yep
See the docs. If you're looking for help with specific frameworks or build systems (React, Angular, Webpack, Ember, etc), check out the ecosystem wiki
Also, check out this step by step guide.
For a full example, check out this simple webpack example.
To create a single-spa application, you will need to do three things:
- Create an html file:
<html>
<body>
<script src="single-spa-config.js"></script>
</body>
</html>- Create a single-spa-config. Check out the docs for more detail.
// single-spa-config.js
import * as singleSpa from 'single-spa';
const appName = 'app1';
/* The loading function is a function that returns a promise that resolves with the javascript application module.
* The purpose of it is to facilitate lazy loading -- single-spa will not download the code for a application until it needs to.
* In this example, import() is supported in webpack and returns a Promise, but single-spa works with any loading function that returns a Promise.
*/
const loadingFunction = () => import('./app1/app1.js');
/* Single-spa does some top-level routing to determine which application is active for any url. You can implement this routing any way you'd like.
* One useful convention might be to prefix the url with the name of the app that is active, to keep your top-level routing simple.
*/
const activityFunction = location => location.pathname.startsWith('/app1');
singleSpa.registerApplication(appName, loadingFunction, activityFunction);
singleSpa.start();- Create an application. Check out the docs for more detail.
//app1.js
let domEl;
export function bootstrap(props) {
return Promise
.resolve()
.then(() => {
domEl = document.createElement('div');
domEl.id = 'app1';
document.body.appendChild(domEl);
});
}
export function mount(props) {
return Promise
.resolve()
.then(() => {
// This is where you would normally use a framework to mount some ui to the dom. See https://github.com/CanopyTax/single-spa/blob/master/docs/single-spa-ecosystem.md.
domEl.textContent = 'App 1 is mounted!'
});
}
export function unmount(props) {
return Promise
.resolve()
.then(() => {
// This is normally where you would tell the framework to unmount the ui from the dom. See https://github.com/CanopyTax/single-spa/blob/master/docs/single-spa-ecosystem.md
domEl.textContent = '';
})
}We're trying out github's Projects feature (here) and are keeping it up-to-date with the fancy things in the works for single-spa.
See single-spa api and application api.
Please submit a P.R. to this section if you start using single-spa.