shoelace/docs/getting-started/usage.md

Usage

Shoelace components are just regular HTML elements, or "custom elements" to be precise. You can use them like any other element. Each component has detailed documentation that describes its full API, including properties, events, methods, and more.

Web Component Basics

Properties

Many components have properties ("props") that can be set using attributes. For example, buttons accept a size attribute that dictates the button's size.

<sl-button size="small">Click me</sl-button>

Some props are booleans, so they only have true/false values. To activate a boolean prop, add the corresponding attribute without a value.

<sl-button disabled>Click me</sl-button>

In rare cases, a prop may require an array, an object, or a function. For example, to customize the color picker's list of preset swatches, you set the swatches prop to an array of colors. This can be done with JavaScript.

<sl-color-picker></sl-color-picker>

<script>
  const colorPicker = document.querySelector('sl-color-picker');
  colorPicker.swatches = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'];
</script>

Refer to a component's documentation for a complete list of its properties.

Events

You can listen for standard events such as click, mouseover, etc. as you normally would. In addition, some components emit custom events. These work the same way as standard events, but are prefixed with sl to prevent collisions with standard events and other libraries.

<sl-checkbox>Check me</sl-checkbox>

<script>
  const checkbox = document.querySelector('sl-checkbox');
  checkbox.addEventListener('slChange', event => {
    console.log(event.target.checked ? 'checked' : 'not checked');
  });
</script>

Refer to a component's documentation for a complete list of its custom events.

Methods

Some components have methods you can call to trigger various behaviors. For example, you can set focus on a Shoelace input using the setFocus() method.

<sl-input></sl-input>

<script>
  const input = document.querySelector('sl-input');
  input.setFocus();
</script>

Refer to a component's documentation for a complete list of its methods and their arguments.

Slots

Many components use slots to accept content inside of them. The most common slot is the default slot, which includes any content inside the component that doesn't have a slot attribute.

For example, a button's default slot is used to populate its label.

<sl-button>Click me</sl-button>

Some components also have named slots. A named slot can be populated by adding a child element with the appropriate slot attribute. Notice how the icon below has the slot="prefix" attribute? This tells the component to place the icon into its prefix slot.

<sl-button>
  <sl-icon slot="prefix" name="gear"></sl-icon>
  Settings
</sl-button>

The location of a named slot doesn't matter. You can put it anywhere inside the component and the browser will move it to the right place automatically!

Refer to a component's documentation for a complete list of available slots.

Don't Use Self-closing Tags

Custom elements cannot have self-closing tags. Similar to <script> and <textarea>, you must always include the full closing tag.

<!-- Don't do this -->
<sl-input />

<!-- Always do this -->
<sl-input></sl-input>

Differences from Native Elements

You might expect similarly named elements to share the same API as native HTML elements. This is not always the case. Shoelace components are not designed to be one-to-one replacements for their HTML counterparts.

For example, <button> and <sl-button> both have a type attribute, but it does different things (the former controls whether the button submits a form and the latter controls the button's appearance). Similarly, you can't call focus() on a Shoelace input — you need to use the component's setFocus() method instead. There are technical reasons for some of these design decisions that are outside the scope of this page.

?> Don't make assumptions about a component's API! To prevent unexpected behaviors, please take the time to review the documentation and make sure you understand what each property, method, and event is intended to do.

React

React doesn't play nice with custom elements — it's a bit finicky about props.

React passes all data to Custom Elements in the form of HTML attributes. For primitive data this is fine, but the system breaks down when passing rich data, like objects or arrays. In these instances you end up with stringified values like some-attr="[object Object]" which can't actually be used.

Event handling can also be cumbersome.

Because React implements its own synthetic event system, it cannot listen for DOM events coming from Custom Elements without the use of a workaround. Developers will need to reference their Custom Elements using a ref and manually attach event listeners with addEventListener. This makes working with Custom Elements cumbersome.

Fortunately, there's a utility that will wrap Shoelace components so you can use them as if they were React components. 👇

?> If you're starting a new project, consider using Preact as an alternative. It shares the same API as React and handles custom elements quite well.

Wrapping Components

You can use this utility to wrap Shoelace components so they work like like regular React components. To install it, use this command.

npm install @shoelace-style/react-wrapper

Now you can "import" Shoelace components as React components! Remember to install Shoelace as well, otherwise this won't work as intended.

import wrapCustomElement from '@shoelace-style/react-wrapper';

const ShoelaceButton = wrapCustomElement('sl-button');

return <ShoelaceButton type="primary">Click me</ShoelaceButton>;

A reference ("ref") to the underlying custom element is exposed through the element property so you can access it directly. This is useful for calling methods.

<ShoelaceButton 
  ref={el => this.button = el} 
  onClick={() => this.button.element.current.removeFocus()}
>
  Click me
</ShoelaceButton>

Vue

Vue plays nice with custom elements. You just have to tell it to ignore Shoelace components. This is pretty easy because they all start with sl-.

Vue.config.ignoredElements = [/^sl-/];

new Vue({ ... });

Two-way Binding

One caveat is there's currently no support for v-model on custom elements, but you can still achieve two-way binding manually.

<!-- This doesn't work -->
<sl-input v-model="name">

<!-- This works, but it's a bit longer -->
<sl-input :value="name" @input="name = $event.target.value">

If that's too verbose, you can use a custom directive instead. 👇

Using a Custom Directive

You can use this utility to add a custom directive to Vue that will work just like v-model but for Shoelace components. To install it, use this command.

npm install @shoelace-style/vue-sl-model

Next, import the directive and enable it like this.

import ShoelaceModelDirective from '@shoelace-style/vue-sl-model';

Vue.config.ignoredElements = [/^sl-/];
Vue.use(ShoelaceModelDirective);

// Your init here
new Vue({ ... });

Now you can use the v-sl-model directive to keep your data in sync!

<sl-input v-sl-model="name">

Angular

Angular plays nice with custom elements. Just make sure to apply the custom elements schema as shown below.

import { BrowserModule } from '@angular/platform-browser';
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

import { AppComponent } from './app.component';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule],
  providers: [],
  bootstrap: [AppComponent],
  schemas: [CUSTOM_ELEMENTS_SCHEMA]
})
export class AppModule {}