A more comprehensive module system

Core Improvements to the ECMAScript 15 Module System

ECMAScript 15 introduces major upgrades to the module system, offering more flexible import/export mechanisms. Static imports now support conditional loading, and the syntax for dynamic imports has been streamlined. The new module composition feature allows developers to combine multiple modules into a single entry point.

// Example of conditional static import
if (featureFlag) {
  import('./analytics.js').then(module => {
    module.init();
  });
}

Enhanced Module Namespaces

Module namespace objects now support prototype chain access and property descriptor operations. The new import.meta.resolve method resolves relative paths into absolute URLs, which is particularly useful for dynamic resource loading.

// Example of module path resolution
const workerPath = import.meta.resolve('./worker.js');
const worker = new Worker(workerPath);

Resource Loading Optimization

ECMAScript 15 introduces a preloading mechanism via import.preload, allowing dependencies to be fetched before the main module executes. This declarative preloading is more precise than the traditional <link rel="preload">.

// Example of module preloading
import.preload([
  './heavy-computation.js',
  './large-dataset.json'
]);

Module Dependency Analysis API

The new import.dependencies API enables runtime inspection of the module dependency graph. Developers can access the complete dependency tree of a module, which is valuable for build tools and performance analysis.

// Example of dependency analysis
const deps = import.dependencies('./main.js');
console.log(deps);
/*
{
  specifier: './main.js',
  dependencies: [
    { specifier: './util.js', type: 'static' },
    { specifier: './api.js', type: 'dynamic' }
  ]
}
*/

Standardized Module Hot Replacement

ECMAScript 15 formally incorporates Hot Module Replacement (HMR) into the standard, providing a unified import.hot interface. Unlike private implementations in build tools, the standard HMR API ensures consistency across environments.

// Example of standard HMR
import { render } from './ui.js';

if (import.hot) {
  import.hot.accept('./ui.js', newModule => {
    newModule.render();
  });
}

Module Isolation and Security

The new import.isolated flag allows the creation of isolated module contexts, where isolated modules cannot access the main global object. This enhances security for sandbox environments and plugin systems.

// Example of an isolated module
const secureModule = await import('./plugin.js', {
  isolated: true
});

Extended Module Metadata

The import.meta object now includes more runtime information, such as module load time, origin domain, and content hash. This metadata aids debugging and performance monitoring.

// Example of metadata access
console.log(import.meta.loadTime);
console.log(import.meta.origin);
console.log(import.meta.integrity);

Module Cache Control

Developers can now finely control module caching via the import.cache API. Modules can be forcibly reloaded or specific module caches cleared, which is practical for development and testing scenarios.

// Example of cache control
delete import.cache.get('./config.js');
const freshConfig = await import('./config.js');

Module Bundling and Splitting

ECMAScript 15 natively supports the concept of module bundling. Using import.bundle, developers can declare module groups. The runtime can then intelligently load chunks by group, reducing network requests.

// Example of module bundling declaration
import.bundle('admin', [
  './admin-dashboard.js',
  './admin-api.js',
  './admin-utils.js'
]);

Module Lifecycle Hooks

New module lifecycle hooks allow code execution during module loading and unloading. import.onload and import.onunload resemble class static blocks but operate at the module level.

// Example of lifecycle hooks
import.onload(() => {
  console.log('Module loaded');
  return () => {
    console.log('Module unloading');
  };
});

Module Version Control

Standardized module versioning is achieved via import.version, enabling specification or checking of module versions. This resolves dependency conflicts and cache invalidation issues.

// Example of version control
import { algo } from './crypto.js' assert { version: '2.0' };

// Check current version
console.log(import.version('./crypto.js'));

Module Performance Metrics

The new import.metrics object provides detailed loading performance data, including phase durations and resource sizes. These metrics are crucial for performance optimization.

// Example of performance metrics
const metrics = import.metrics('./chart.js');
console.log(metrics.parseTime);
console.log(metrics.executeTime);
console.log(metrics.transferSize);

Enhanced Module Error Handling

Module loading errors now provide more detailed diagnostic information. The new ImportError class includes context such as module paths and dependency chains, facilitating debugging of complex dependency issues.

// Example of error handling
try {
  await import('./missing.js');
} catch (e) {
  if (e instanceof ImportError) {
    console.error(`Failed to load: ${e.specifier}`);
    console.error(`Dependency chain: ${e.dependencyChain.join(' -> ')}`);
  }
}

Module and Web Component Integration

ECMAScript 15 improves the integration of modules with web components. Modules can now directly export custom element definitions, simplifying the component registration process.

// Example of a web component module
// my-component.js
export class MyComponent extends HTMLElement {
  // Component implementation
}

export const definition = {
  name: 'my-component',
  constructor: MyComponent
};

// Using the component
import { definition } from './my-component.js';
customElements.define(definition.name, definition.constructor);

Module Type Annotations

Although ECMAScript remains dynamically typed, the module system now supports optional type annotations. These annotations are ignored at runtime but can be used by toolchains for static analysis.

// Example of type annotations
/**
 * @type {import('./types').User}
 */
export const currentUser = {
  id: '123',
  name: 'Alice'
};

Module Resource Inlining

The new import.inline directive allows small resources (e.g., images, JSON) to be inlined into modules. This reduces HTTP requests for small files while maintaining code maintainability.

// Example of resource inlining
const logo = import.inline('./logo.svg');
const config = import.inline('./defaults.json');

Module and Web Worker Optimization

ECMAScript 15 simplifies module usage in Web Workers. Workers can now directly import modules without conversion, and shared module instances are supported.

// Example of a worker module
// main.js
const worker = new Worker('./worker.js', {
  type: 'module',
  sharedModules: ['./shared-utils.js']
});

// worker.js
import { utility } from './shared-utils.js';