A javascript metaframework
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.
- Hot reload entire chunks of your overall application (instead of individual files).
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 child applications, each of which is sort of like an entire SPA itself. Child applications respond to url routing events and must know how to bootstrap, mount, and unmount themselves from the DOM. The main difference between an SPA and a child application is that child applications must coexist together and do not each have their own html page. For example, your React or Angular applications are child 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 root application. The root application is the html page, plus the javascript that registers child applications with single-spa. Each child application is registered with three things:
- A name
- A function to load the child application's code
- A function that determines when the child 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 child 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="root-application.js"></script>
</body>
</html>- Create a root application. Check out the docs for more detail.
// root-application.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 child application module.
* The purpose of it is to facilitate lazy loading -- single-spa will not download the code for a child 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 child 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.hash.startsWith('#/app1');
singleSpa.declareChildApplication(appName, loadingFunction, activityFunction);
singleSpa.start();- Create a child 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 = '';
})
}See single-spa api and child application api.
Please submit a P.R. to this section if you start using single-spa.