@material/base

What is @material/base?

@material/base is a foundational package for building Material Design components. It provides base classes and utilities that help in creating custom components that adhere to Material Design guidelines.

What are @material/base's main functionalities?

Foundation Class

The Foundation class is a base class for creating the logic of a Material Design component. It provides a structure for defining the component's behavior and lifecycle methods.

const { MDCFoundation } = require('@material/base');

class MyComponentFoundation extends MDCFoundation {
  constructor(adapter) {
    super(Object.assign(MyComponentFoundation.defaultAdapter, adapter));
  }

  static get defaultAdapter() {
    return {
      addClass: () => {},
      removeClass: () => {},
      // other adapter methods
    };
  }

  // Foundation methods
  init() {
    // Initialization logic
  }

  destroy() {
    // Cleanup logic
  }
}

module.exports = MyComponentFoundation;

Adapter Pattern

The Adapter pattern is used to abstract the DOM manipulation and other platform-specific operations. This allows the foundation logic to be platform-agnostic and reusable.

const { MDCFoundation } = require('@material/base');

class MyComponentAdapter {
  addClass(className) {
    // Add class to the component
  }

  removeClass(className) {
    // Remove class from the component
  }

  // Other adapter methods
}

class MyComponentFoundation extends MDCFoundation {
  constructor(adapter) {
    super(Object.assign(MyComponentFoundation.defaultAdapter, adapter));
  }

  static get defaultAdapter() {
    return {
      addClass: () => {},
      removeClass: () => {},
      // other adapter methods
    };
  }
}

module.exports = { MyComponentAdapter, MyComponentFoundation };

Component Initialization

The Component class is used to initialize and manage the lifecycle of a Material Design component. It ties together the foundation and adapter to create a fully functional component.

const { MDCComponent } = require('@material/base');
const MyComponentFoundation = require('./my-component-foundation');

class MyComponent extends MDCComponent {
  static attachTo(root) {
    return new MyComponent(root, new MyComponentFoundation());
  }

  getDefaultFoundation() {
    return new MyComponentFoundation({
      addClass: (className) => this.root_.classList.add(className),
      removeClass: (className) => this.root_.classList.remove(className),
      // other adapter methods
    });
  }
}

module.exports = MyComponent;

Other packages similar to @material/base

react-material-ui

React Material-UI is a popular library for implementing Material Design components in React applications. It provides a wide range of pre-built components that follow Material Design guidelines, making it easier to build consistent UIs. Unlike @material/base, which is more of a foundational library, React Material-UI offers ready-to-use components.

vuetify

Vuetify is a Material Design component framework for Vue.js. It offers a comprehensive suite of pre-built components that adhere to Material Design specifications. Similar to React Material-UI, Vuetify provides ready-to-use components, whereas @material/base is more focused on providing the building blocks for custom components.

angular-material

Angular Material is a UI component library for Angular developers that implements Material Design. It provides a set of reusable, well-tested, and accessible UI components based on Material Design. Angular Material is more feature-complete compared to @material/base, which serves as a foundation for building custom components.

README

Base

MDC Base contains core foundation and component classes that serve as the base classes for all of MDC Web's foundation classes and components (respectively).

Most of the time, you shouldn't need to depend on mdc-base directly. It is useful however if you'd like to write custom components that follow MDC Web's pattern and elegantly integrate with the MDC Web ecosystem.

Installation

First install the module:

npm install @material/base

Then include it in your code in one of the following ways:

ES Module syntax

import {MDCComponent, MDCFoundation} from '@material/base';

CommonJS

const MDCComponent = require('mdc-base').MDCComponent;
const MDCFoundation = require('mdc-base').MDCFoundation;

AMD

require(['path/to/mdc-base'], function(mdcBase) {
  const MDCComponent = mdcBase.MDCComponent;
  const MDCFoundation = mdcBase.MDCFoundation;
});

Vanilla

const MDCComponent = mdc.base.MDCComponent;
const MDCFoundation = mdc.base.MDCFoundation;

Usage

mdc-base exposes two classes: MDCComponent (the default export) which all components extend from, and MDCFoundation, which all foundation classes extend from. To learn more about foundation classes vs. components, check out our overview on architecture and best practices.

MDCFoundation

MDCFoundation provides the basic mechanisms for implementing foundation classes. Subclasses are expected to:

• Provide implementations of the proper static getters where necessary.
• Provide init() and destroy() lifecycle methods

import {MDCFoundation} from '@material/base/foundation';

export default class MyFoundation extends MDCFoundation {
  static get cssClasses() {
    return {
      ROOT: 'my-component',
      MESSAGE: 'my-component__message',
      BUTTON: 'my-component__button',
      TOGGLED: 'my-component--toggled'
    };
  }

  static get defaultAdapter() {
    return {
      toggleClass: (/* className: string */) => {},
      registerBtnClickHandler: (/* handler: Function */) => {},
      deregisterBtnClickHandler: (/* handler: Function */) => {}
    };
  }

  constructor(adapter) {
    super({...MyFoundation.defaultAdapter, ...adapter});
    const {TOGGLED} = MyFoundation.cssClasses;
    this.clickHandler = () => this.adapter.toggleClass(TOGGLED);
  }

  init() {
    this.adapter.registerBtnClickHandler(this.clickHandler);
  }

  destroy() {
    this.adapter.deregisterBtnClickHandler(this.clickHandler);
  }
}

Static Getters

The static getters specify constants that can be used within the foundation class, its component, and by 3rd-party code. It's important to remember to always put constants into these getters. This will ensure your component can interop in as many environments as possible, including those where CSS classes need to be overwritten by the host library (e.g., Closure Stylesheets), or strings need to be modified (for i18n, for example).

Note that you do not have to explicitly provide getters for constants if your component has none.

The getters which should be provided are specified below:

getter	description
cssClasses	returns an object where each key identifies a css class that some code will rely on.
strings	returns an object where each key identifies a string constant, e.g. ARIA_ROLE
numbers	returns an object where each key identifies a numeric constant, e.g. TRANSITION_DELAY_MS
defaultAdapter	returns an object specifying the shape of the adapter. Can be used as sensible defaults for an adapter as well as a way to specify your adapter's "schema"

Lifecycle Methods

Each foundation class has two lifecycle methods: init() and destroy(), which are described below:

method	time of invocation	use case
init()	called by a host class when a component is ready to be initialized	add event listeners, query for info via adapters, etc.
destroy()	called by a host class when a component is no longer in use	remove event listeners, reset any transient state, etc.

MDCComponent

MDCComponent provides the basic mechanisms for implementing component classes.

import MyComponentFoundation from './foundation';

export class MyComponent extends MDCComponent {
  static attachTo(root) {
    return new MyComponent(root);
  }

  getDefaultFoundation() {
    const btn = this.root.querySelector(`.${MyComponentFoundation.cssClasses.BUTTON}`);
    return new MyComponentFoundation({
      toggleClass: className => {
        if (this.root.classList.contains(className)) {
          this.root.classList.remove(className);
          return;
        }
        this.root.classList.add(className);
      },
      registerBtnClickHandler: handler => btn.addEventListener('click', handler),
      deregisterBtnClickHandler: handler => btn.removeEventListener('click', handler)
    });
  }
}

Properties

MDCComponent provides the following "private" properties to subclasses:

property	description
root	The root element passed into the constructor as the first argument.
foundation	The foundation class for this component. This is either passed in as an optional second argument to the constructor, or assigned the result of calling getDefaultFoundation()

Methods

MDCComponent provides the following methods to subclasses:

method	description
initialize(...args)	Called after the root element is attached to the component, but before the foundation is instantiated. Any positional arguments passed to the component constructor after the root element, along with the optional foundation 2nd argument, will be provided to this method. This is a good place to do any setup work normally done within a constructor function.
getDefaultFoundation()	Returns an instance of a foundation class properly configured for the component. Called when no foundation instance is given within the constructor. Subclasses must implement this method.
initialSyncWithDOM()	Called within the constructor. Subclasses may override this method if they wish to perform initial synchronization of state with the host DOM element. For example, a slider may want to check if its host element contains a pre-set value, and adjust its internal state accordingly. Note that the same caveats apply to this method as to foundation class lifecycle methods. Defaults to a no-op.
destroy()	Subclasses may override this method if they wish to perform any additional cleanup work when a component is destroyed. For example, a component may want to deregister a window resize listener.
listen(type: string, handler: EventListener)	Adds an event listener to the component's root node for the given type. Note that this is simply a proxy to this.root.addEventListener.
unlisten(type: string, handler: EventListener)	Removes an event listener from the component's root node. Note that this is simply a proxy to this.root.removeEventListener.
emit(type: string, data: Object, shouldBubble: boolean = false)	Dispatches a custom event of type type with detail data from the component's root node. It also takes an optional shouldBubble argument to specify if the event should bubble. This is the preferred way of dispatching events within our vanilla components.

Static Methods

In addition to methods inherited, subclasses should implement the following two static methods within their code:

method	description
attachTo(root) => <ComponentClass>	Subclasses must implement this as a convenience method to instantiate and return an instance of the class using the root element provided. This will be used within mdc-auto-init, and in the future its presence may be enforced via a custom lint rule.

Foundation Lifecycle handling

MDCComponent calls its foundation's init() function within its constructor, and its foundation's destroy() function within its own destroy() function. Therefore it's important to remember to always call super() when overriding destroy(). Not doing so can lead to leaked resources.

Initialization and constructor parameters

If you need to pass in additional parameters into a component's constructor, you can make use of the initialize method, as shown above. An example of this is passing in a child component as a dependency.

class MyComponent extends MDCComponent {
  initialize(childComponent = null) {
    this.child = childComponent ?
      childComponent : new ChildComponent(this.root.querySelector('.child'));
  }

  getDefaultFoundation() {
    return new MyComponentFoundation({
      doSomethingWithChildComponent: () => this.child.doSomething(),
      // ...
    });
  }
}

You could call this code like so:

const childComponent = new ChildComponent(document.querySelector('.some-child'));
const myComponent = new MyComponent(
  document.querySelector('.my-component'), /* foundation */ undefined, childComponent
);
// use myComponent

NOTE: You could also pass in an initialized foundation if you wish. The example above simply showcases how you could pass in initialization arguments without instantiating a foundation.

Best Practice: Keep your adapters simple

If you find your adapters getting too complex, you should consider refactoring the complex parts out into their own implementations.

import MyComponentFoundation from './foundation';
import {toggleClass} from './util';

class MyComponent {
  // ...
  getDefaultFoundation() {
    return new MyComponentFoundation({
      toggleClass: className => util.toggleClass(this.root, className),
      // ...
    });
  }
}

Where ./util could look like:

export function toggleClass(element, className) {
  if (root.classList.contains(className)) {
    root.classList.remove(className);
    return;
  }
  root.classList.add(className);
}

This not only reduces the complexity of your component class, but allows for the functionality of complex adapters to be adequately tested:

test('toggleClass() removes a class when present on an element', t => {
  const root = document.createElement('div');
  root.classList.add('foo');

  util.toggleClass(root, 'foo');

  t.false(root.classList.contains('foo'));
  t.end();
});

Changelog

12.0.0 (2021-07-27)

Bug Fixes

• base: observer now listens to superclass properties (88a33cd)
• button: allow Mac zoom service to access button label (29ac6ec)
• button: Fix non-text buttons with icons to have reduced horizontal padding on the side with the icon. (197f64f)
• chips: Add documentation for action (3db4d16)
• chips: Add documentation for chip; update action docs (22b83ad)
• chips: Add stubbed component methods along with tests (06930c9)
• chips: Document chip set; add root readme (5b6a460)
• chips: Hide HCM focus indicator for presentational actions (8c7d994)
• chips: Update chip set links (4a7939c)
• circular-progress: set explicit line-height to prevent inheritance (e8e39ad), closes #7118
• dialog: prevent programmatic click on disabled default button (e0c3462)
• fab: Fixed Fab ripple (84f3db9), closes #7053
• icon-button: prevent icon shift on press in IE11 (8fc2927)
• linear-progress: allow parent visibility prop to propagate to bar (e543628)
• list: Add core-styles mixin. (fc7c4e5)
• list: density configuration mixins do not account for leading avatars (3674c62)
• list: Ensure trailing-only variants have leading padding in RTL contexts. (81e2d4f)
• list: Fixed the selected + focused state of list item in HCM (8ba3e29)
• list: Reset selectedIndex to UNSET_INDEX if #setSingleSelection(true) is called and there are no selected list items. (4eecdea)
• list: Selection lists without a selection focus first item. (03f525f)
• list: Use more descriptive foundation method comments (08d791f)
• mdc-list: invalid syntax in generated .d.ts bundle (ce82846)
• menu: correct menu opening delay (a618380), closes #5682 #4411
• menu-surface: slightly delay focus restoration to prevent lost focus on mobile devices (9f68a93)
• ripple: ensure custom properties are always emitted (caa73ae)
• rtl: do not emit if a left/right value or replacement is null (ec4ac52)
• rtl: mixins work with pseudo elements (f5b6110)
• switch: export temporary deprecated version (bd68539)
• switch: misaligned handle when inside some flex containers (ea1e1b8)
• switch: move ripple behind handle (3e4c6dc)
• switch: overlay colors not showing and support -5 density (33579e0)
• switch: prevent collapsing in flex containers (22f390c)
• switch: track colors can have opacity and not bleed through (d923db7)
• tabscroller: remove trailing underscore (105b15b)
• text-field: remove disabled white patch in high contrast mode for Firefox 89+ (17553e9)
• prepare for #7183 (#7188) (77b94e8)
• text-field: show filled textarea label in Firefox 89+ high contrast (90e08fc)
• textfield: announce error message again if user blurs already invalid field (75900a5)
• tooltip: Adding missing return statement into MDCTooltipComponent#isShown method. (4d95812)
• tooltip: Fixing component definition of MDCTooltipAdatper#deregisterAnchorEventHandler. (d928692)
• tooltip: Fixing logic for determining whether or not the user intends a tooltip to be hidden from the screenreader or not. (cf5b9eb)
• Remove lint check from test actions (#7185) (1ee1fbf)
• touch-target: incorrect position in rtl when width is set (bd1b4e9)

Build System

• set AMD module module names within UMD bundles (#7233) (9808de0)

Code Refactoring

• checkbox: Deprecated old checkbox theme mixin (22d29cb)
• iconbutton: Move ripple target to inner element (33c9a73)

Features

• base: add MDCObserverFoundation class (33e6f50)
• button: Add focus indicator to link buttons in HCM. (cad4896)
• button: add typography & state layer keys to theming API (068fd50)
• button: employ elevation token resolvers in theming API (ebb5c73)
• button: move icon-size to theming API (85e9a6a)
• card: Moving ripple into a mdc-card__ripple element rather than the mdc-card__primary-action. (8ace3b8)
• checkbox: Added new theme mixin in checkbox to match token keys (33a9548)
• checkbox: Added new theme mixin in checkbox to match token keys (8e60818)
• chips: Support presentational actions (8c68530)
• dialog: removing call to #close within #destroy. (5631828)
• dom: add forced-colors-mode mixin (8416fb9)
• elevation: Create elevation resolver mixin (5dfec7a)
• elevation: Create resolver function (c18b592)
• elevation: Simplify box-shadow custom property support (de48eff)
• elevation: Support custom properties in resolver (07a7375)
• fab: Added mixin that auto-generates custom properties for Fab (8530d35)
• fab: Added mixin to auto-generate custom properties for Fab (14767a8)
• fab: Use elevation resolvers (6e9fc4a)
• fab: Use elevation resolvers in custom property themes (3f691ec)
• iconbutton: Add support for increased touch target to icon button. (f43af56)
• list: Add public #getFocusedItemIndex to foundation. Also add a forceUpdate option to #setSelectedIndex that forces a UI update of the selected item. (5d06051)
• list: Basic support for three-line lists. (4bb5eea)
• menu: Add public #getSelectedIndex to foundation. (f705e80)
• radio: Added theme mixin that declares custom properties in MDC radio (b87ebf7)
• radio: Added theme styles mixin to MDC radio (464a002)
• radio: Added theme styles mixin to Radio (5823407)
• ripple: Added theme styles and theme mixin to Ripple (a2b0f4c)
• select: Add #getUseDefaultValidation method to foundation. (adeac05)
• shape: add shape map theme value support (ec31ae1)
• slider: Expose changing certain props after initialization to support MWC (3f36ac7)
• switch: add custom property theming support (f147a22)
• switch: add density custom property support (598fccc)
• switch: add new component and foundation (ef43e6d)
• switch: add updated density styles (cb162da)
• switch: add updated RTL styles (573dc7f)
• switch: update switch to new design spec (0ce2fdb)
• switch: update theme keys (00b5899)
• switch: Use elevation token resolvers (e1703be)
• tabs: Add theming API to tabs (bd25779)
• tabs: Added theme-styles() mixin to tabs (e38d744)
• test: Add overline support to two- and three-line lists. (38d1846)
• test: Add shape radius mixins to list. (d5f1f7c)
• theme: add map-ext.split() helper function (ec22e1d)
• theme: add state selector mixins (d20dc6d)
• theme: gss.annotate supports named arguments (c50d20b)
• theme: theme.property() supports custom prop declarations (474836a)
• tooltip: Adding foundation methods to allow users to configure the tooltip show and hide delay time. (08db3d7)
• tooltip: Adds logic for generating a new tooltip position when all "standard" positions for tooltip w/ caret are invalid. (9bc0eff)
• tooltip: Adds logic to determine valid position options for tooltip w/caret, and select which should be used. (2ebfc53)
• tooltip: Adjusting transform-origin for tooltips with caret so that the entrance animation originates from the caret. (1a8d064)
• Create token package with resolvers (9405502)
• tooltip: Adjusting logic and styles so the caret better matches spec. (55ad2d7)
• tooltip: Fixes ordering of values provided to tranform-origin. (25751d2)
• tooltip: Plain tooltips remain visible if the user hovers over them. (ccce99c)

Reverts

• checkbox: Added new theme mixin in checkbox to match token keys (b4c3f51)

BREAKING CHANGES

• tooltip: - Tooltips intended to be hidden from the screen reader should be annotated with data-hide-tooltip-from-screenreader="true" (in addition to using data-tooltip-id rather than aria-describedby.

PiperOrigin-RevId: 386490861

• Breaking change for the UMD-case where the exports are bound to a global variable. Previously the entry-point would appear in camel-case, but now it's matching the actual package name in dash-case. This is unfortunately not avoidable with the current Webpack tooling. i.e. previous UMD users relying on the globals (which are rather rare anyway), would need to switch from window.mdc.circularProgress to window.mdc['circular-progress].
• checkbox: Renamed old checkbox theme mixin for deprecation

PiperOrigin-RevId: 384568221

• iconbutton: Icon button now requires an inner ripple element with class mdc-icon-button__ripple. See README for details.

PiperOrigin-RevId: 372153409