systemjs

What is systemjs?

SystemJS is a dynamic module loader that can load ES modules, AMD, CommonJS, and global scripts in the browser and Node.js. It provides a way to load modules asynchronously and supports various module formats, making it a versatile tool for managing dependencies and module loading in JavaScript applications.

What are systemjs's main functionalities?

Loading ES Modules

SystemJS can dynamically import ES modules. The code sample demonstrates how to load an ES module asynchronously and handle the loaded module.

System.import('/path/to/module.js').then(function(module) {
  console.log(module);
});

Loading CommonJS Modules

SystemJS can also load CommonJS modules. The code sample shows how to load a CommonJS module asynchronously.

System.import('/path/to/commonjs-module.js').then(function(module) {
  console.log(module);
});

Loading AMD Modules

SystemJS supports loading AMD modules. The code sample demonstrates how to load an AMD module asynchronously.

System.import('/path/to/amd-module.js').then(function(module) {
  console.log(module);
});

Loading Global Scripts

SystemJS can load global scripts that do not export any modules. The code sample shows how to load a global script asynchronously.

System.import('/path/to/global-script.js').then(function() {
  console.log('Global script loaded');
});

Configuring SystemJS

SystemJS allows configuration for module loading. The code sample demonstrates how to configure the base URL, paths, and module mappings.

System.config({
  baseURL: '/base/url',
  paths: {
    'npm:': 'https://unpkg.com/'
  },
  map: {
    'jquery': 'npm:jquery@3.5.1/dist/jquery.js'
  }
});

Other packages similar to systemjs

requirejs

RequireJS is a JavaScript file and module loader. It is optimized for in-browser use, but it can be used in other JavaScript environments, such as Rhino and Node. Compared to SystemJS, RequireJS primarily focuses on AMD modules and does not support as many module formats.

webpack

Webpack is a module bundler that takes modules with dependencies and generates static assets representing those modules. Unlike SystemJS, which is a dynamic module loader, Webpack bundles modules at build time, which can result in better performance for production applications.

browserify

Browserify allows you to use Node.js-style require() to organize your browser code and load modules. It transforms Node.js modules into a format that can be used in the browser. Compared to SystemJS, Browserify focuses on CommonJS modules and does not support as many module formats.

es-module-loader

ES Module Loader is a polyfill for the ES Module Loader specification. It provides a way to load ES modules in environments that do not natively support them. Compared to SystemJS, ES Module Loader is more focused on ES modules and does not support other module formats.

README

SystemJS

For upgrading to SystemJS 0.17-0.19, see the SystemJS 0.17 release upgrade notes for more information, or read the updated SystemJS Overview guide.

Universal dynamic module loader - loads ES6 modules, AMD, CommonJS and global scripts in the browser and NodeJS. Works with both Traceur and Babel.

• Loads any module format with exact circular reference and binding support.
• Loads ES6 modules compiled into the System.register bundle format for production, maintaining circular references support.
• Supports RequireJS-style map, paths, bundles and global shims.
• Loader plugins allow loading assets through the module naming system such as CSS, JSON or images.

Built on top of the ES6 Module Loader polyfill.

~15KB minified and gzipped, runs in IE8+ and NodeJS.

For discussion, see the Google Group.

For a list of guides and tools, see the Third-Party Resources Wiki.

Documentation

• ES6 Modules Overview
• SystemJS Overview
• Config API
• Module Formats
• Production Workflows
• System API
• Creating Plugins

Basic Use

Browser

<script src="system.js"></script>
<script>
  // set our baseURL reference path
  System.config({
    baseURL: '/app'
  });

  // loads /app/main.js
  System.import('main.js');
</script>

To load ES6, locate a transpiler (traceur.js, 'browser.js' from Babel, or 'typescript.js' from TypeScript) in the baseURL path, then set the transpiler:

<script>
  System.config({
    // or 'traceur' or 'typescript'
    transpiler: 'babel',
    // or traceurOptions or typescriptOptions
    babelOptions: {

    }
  });
</script>

Alternatively a custom path to Babel or Traceur can also be set through paths:

System.config({
  map: {
    traceur: 'path/to/traceur.js'
  }
});

Promise Polyfill

SystemJS relies on Promise being present in the environment.

For the best performance in IE and older browsers, it is advisable to load Bluebird or es6-promise before SystemJS.

Otherwise, when Promise is not available, SystemJS will attempt to load the system-polyfills.js file located in the dist folder which contains the when.js Promise polyfill.

NodeJS

To load modules in NodeJS, install SystemJS with:

  npm install systemjs

If transpiling ES6, also install the transpiler:

  npm install traceur babel typescript 

We can then load modules equivalently to in the browser:

var System = require('systemjs');

System.transpiler = 'traceur';

// loads './app.js' from the current directory
System.import('./app.js').then(function(m) {
  console.log(m);
});

If using TypeScript, set global.ts = require('typescript') before importing to ensure it is loaded correctly.

If you are using jspm as a package manager you will also need to load the generated config.js. The best way to do this in node is to get your System instance through jspm, which will automatically load your config correctly for you:

var System = require('jspm').Loader();

System.import('lodash').then(function (_) {
 console.log(_);
});

Plugins

Supported loader plugins:

• CSS
• Image
• JSON
• Text
• Node Binary

Additional Plugins:

• Audio
• CoffeeScript
• Ember Handlebars
• Handlebars
• HTML
• Image (lazy)
• Jade
• Jade VirtualDOM
• jst
• JSX
• Markdown
• raw
• SASS
• SCSS
• sofe
• SVG
• WebFont
• YAML

Guides:

• Using plugins
• Creating plugins

Running the tests

To install the dependencies correctly, run bower install from the root of the repo, then open test/test.html in a browser with a local server or file access flags enabled.

License

MIT