avaScript Microfrontend Patterns for Scalable Web Applications

As a prolific author, I encourage you to explore my books on Amazon. Remember to follow my work on Medium for continued support. Thank you! Your engagement is invaluable!

Microfrontend architecture has gained significant traction as a solution for building large-scale, maintainable web applications. Having worked on numerous extensive projects, I've directly experienced the advantages of decomposing monolithic frontends into smaller, more manageable units. This article details eight JavaScript microfrontend architectural patterns to enhance application flexibility and scalability.

Monorepo Structure

A crucial initial decision in microfrontend implementation involves codebase organization. A monorepo structure, housing multiple frontend applications within a single repository, proves highly beneficial.

Monorepos simplify code sharing between microfrontends and streamline version control. They foster consistency and simplify dependency management.

A sample monorepo structure:

<code>my-microfrontend-app/
├── packages/
│   ├── header/
│   ├── footer/
│   ├── product-list/
│   └── shopping-cart/
├── shared/
│   ├── components/
│   └── utils/
├── package.json
└── lerna.json</code>

Each microfrontend exists as a separate package within the packages directory. Shared resources reside in the shared directory.

Module Federation

Webpack 5's Module Federation dynamically loads and shares code between applications—ideal for microfrontends, enabling runtime component loading.

A basic Module Federation configuration:

<code>// webpack.config.js
const ModuleFederationPlugin = require('webpack/lib/container/ModuleFederationPlugin');

module.exports = {
  // ...other webpack config
  plugins: [
    new ModuleFederationPlugin({
      name: 'app1',
      filename: 'remoteEntry.js',
      exposes: {
        './Button': './src/Button',
      },
      shared: ['react', 'react-dom'],
    }),
  ],
};</code>

This exposes a Button component from app1 for use by other microfrontends.

Custom Elements

Web Components, especially Custom Elements, create reusable, framework-agnostic components. This is crucial in microfrontend architectures where teams might utilize different frameworks.

A Custom Element example:

<code>class MyCustomElement extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({ mode: 'open' });
  }

  connectedCallback() {
    this.shadowRoot.innerHTML = `

        /* Styles for the custom element */
      <div>
        <h1>My Custom Element</h1>
        <p>This is a custom element used in a microfrontend architecture.</p>
      </div>
    `;
  }
}

customElements.define('my-custom-element', MyCustomElement);</code>

This element functions across microfrontends regardless of their underlying frameworks.

Single-SPA Framework

Single-SPA is a dedicated microfrontend framework. It facilitates building applications from independently developed and deployed microfrontends.

A basic Single-SPA setup:

<code>import { registerApplication, start } from 'single-spa';

registerApplication({
  name: 'app1',
  app: () => import('./app1/main.js'),
  activeWhen: '/app1',
});

registerApplication({
  name: 'app2',
  app: () => import('./app2/main.js'),
  activeWhen: '/app2',
});

start();</code>

This registers app1 and app2, activating them based on the route.

Event-Driven Communication

Effective communication between loosely coupled microfrontends is essential. Event-driven approaches, using pub/sub or custom events, are highly effective.

A custom event example:

<code>// In one microfrontend
const event = new CustomEvent('itemAdded', { detail: { itemId: 123 } });
window.dispatchEvent(event);

// In another microfrontend
window.addEventListener('itemAdded', (event) => {
  console.log('Item added:', event.detail.itemId);
});</code>

This allows communication without exposing internal details.

Shared State Management

While event-driven communication suffices for many situations, centralized state management (Redux, MobX) ensures consistency across microfrontends.

A basic Redux example:

<code>my-microfrontend-app/
├── packages/
│   ├── header/
│   ├── footer/
│   ├── product-list/
│   └── shopping-cart/
├── shared/
│   ├── components/
│   └── utils/
├── package.json
└── lerna.json</code>

Shared state ensures consistent data access.

Asset Loading Strategies

Performance is critical. Smart asset loading, like lazy loading, is vital. A React example:

<code>// webpack.config.js
const ModuleFederationPlugin = require('webpack/lib/container/ModuleFederationPlugin');

module.exports = {
  // ...other webpack config
  plugins: [
    new ModuleFederationPlugin({
      name: 'app1',
      filename: 'remoteEntry.js',
      exposes: {
        './Button': './src/Button',
      },
      shared: ['react', 'react-dom'],
    }),
  ],
};</code>

Lazy loading reduces initial bundle size.

Standardized Build Process

Consistent build processes across microfrontends are crucial for simplifying deployment and reducing errors. A package.json example:

<code>class MyCustomElement extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({ mode: 'open' });
  }

  connectedCallback() {
    this.shadowRoot.innerHTML = `

        /* Styles for the custom element */
      <div>
        <h1>My Custom Element</h1>
        <p>This is a custom element used in a microfrontend architecture.</p>
      </div>
    `;
  }
}

customElements.define('my-custom-element', MyCustomElement);</code>

Consistent build tools ensure uniformity.

These patterns enhance microfrontend architecture. However, remember that each project is unique, and selecting the appropriate patterns is key. Careful planning is crucial for successful implementation.

---

101 Books

101 Books is an AI-powered publishing house co-founded by author Aarav Joshi. Our AI technology keeps publishing costs low—some books cost as little as $4—making knowledge accessible.

Find our book Golang Clean Code on Amazon.

Stay updated! Search for Aarav Joshi for more titles and special offers!

Our Creations

Explore our work:

Investor Central | Investor Central Spanish | Investor Central German | Smart Living | Epochs & Echoes | Puzzling Mysteries | Hindutva | Elite Dev | JS Schools

---

We are on Medium

Tech Koala Insights | Epochs & Echoes World | Investor Central Medium | Puzzling Mysteries Medium | Science & Epochs Medium | Modern Hindutva

The above is the detailed content of avaScript Microfrontend Patterns for Scalable Web Applications. For more information, please follow other related articles on the PHP Chinese website!