Reactivity

Declare state

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("x-name")
export class XName extends LitElement {
  @state()
  name = "John";

  render() {
    return html`<h1>Hello ${this.name}!</h1>`;
  }
}

Ember Polaris

import Component from "@glimmer/component";

export default class NameComponent extends Component {
  name = "John";

  <template>
    <h1>Hello {{this.name}}</h1>
  </template>
}

Update state

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("x-name")
export class XName extends LitElement {
  @state()
  name = "John";

  constructor() {
    super();
    this.name = "Jane";
  }

  render() {
    return html`<h1>Hello ${this.name}!</h1>`;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class CounterComponent extends Component {
  @tracked name = "John";

  constructor(owner, args) {
    super(owner, args);

    this.name = "Jane";
  }

  <template>
    <h1>Hello {{this.name}}</h1>
  </template>
}

Computed state

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("double-count")
export class DoubleCount extends LitElement {
  @state()
  count = 10;

  render() {
    const doubleCount = this.count * 2;
    return html`<div>${doubleCount}</div>`;
  }
}

Ember Polaris

import Component, { tracked } from "@glimmer/component";

export default class DoubleCount extends Component {
  @tracked count = 10;

  get doubleCount() {
    return this.count * 2;
  }

  <template>
    <div>{{this.doubleCount}}</div>
  </template>
}

Templating

Minimal template

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";

@customElement("hello-world")
export class HelloWorld extends LitElement {
  render() {
    return html`<h1>Hello world</h1>`;
  }
}

Ember Polaris

<template>
  <h1>Hello world</h1>
</template>

Styling

Lit

import { LitElement, html, css } from "lit";
import { customElement } from "lit/decorators.js";
import { styleMap } from "lit/directives/style-map.js";

@customElement("css-style")
export class CssStyle extends LitElement {
  static styles = css`
    .title {
      color: red;
    }
  `;

  render() {
    return html`
      <h1 class="title">I am red</h1>
      <button style=${styleMap({ fontSize: "10rem" })}>I am a button</button>
    `;
  }
}

Ember Polaris

<template>
  <h1 class="title">I am red</h1>
  <button style="font-size: 10rem;">I am a button</button>

  <style>
    .title {
      color: red;
    }
  </style>
</template>

Loop

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";
import { repeat } from "lit/directives/repeat.js";

@customElement("colors-list")
export class ColorsList extends LitElement {
  colors = ["red", "green", "blue"];

  render() {
    return html`
      <ul>
        ${repeat(
          this.colors,
          (color) => color,
          (color) => html`<li>${color}</li>`,
        )}
      </ul>
    `;
  }
}

Ember Polaris

const colors = ["red", "green", "blue"];

<template>
  <ul>
    {{#each colors as |color|}}
      <li>{{color}}</li>
    {{/each}}
  </ul>
</template>

Event click

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("x-counter")
export class XCounter extends LitElement {
  @state()
  count = 0;

  incrementCount() {
    this.count = this.count + 1;
  }

  render() {
    return html`
      <p>Counter: ${this.count}</p>
      <button @click=${this.incrementCount}>+1</button>
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class Counter extends Component {
  @tracked count = 0;

  incrementCount = () => this.count++;

  <template>
    <p>Counter: {{this.count}}</p>
    <button {{on "click" this.incrementCount}}>+1</button>
  </template>
}

Dom ref

Lit

import { LitElement, html } from "lit";
import { customElement, state, query } from "lit/decorators.js";

@customElement("input-focused")
export class InputFocused extends LitElement {
  @query("input") inputEl;

  firstUpdated() {
    this.inputEl.focus();
  }

  render() {
    return html`<input type="text" />`;
  }
}

Ember Polaris

import { modifier } from "ember-modifier";

const autofocus = modifier((element) => element.focus());

<template>
  <input {{autofocus}} />
</template>

Conditional

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";
import { choose } from "lit/directives/choose.js";

const TRAFFIC_LIGHTS = ["red", "orange", "green"];

@customElement("traffic-light")
export class TrafficLight extends LitElement {
  @state()
  lightIndex = 0;

  get light() {
    return TRAFFIC_LIGHTS[this.lightIndex];
  }

  nextLight() {
    this.lightIndex = (this.lightIndex + 1) % TRAFFIC_LIGHTS.length;
  }

  render() {
    return html`
      <button @click=${this.nextLight}>Next light</button>
      <p>Light is ${this.light}</p>
      <p>
        You must
        ${choose(this.light, [
          ["red", () => html`<span>STOP</span>`],
          ["orange", () => html`<span>SLOW DOWN</span>`],
          ["green", () => html`<span>GO</span>`],
        ])}
      </p>
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

const TRAFFIC_LIGHTS = ["red", "orange", "green"];

export default class TrafficLight extends Component {
  @tracked lightIndex = 0;

  get light() {
    return TRAFFIC_LIGHTS[this.lightIndex];
  }

  nextLight = () => {
    this.lightIndex = (this.lightIndex + 1) % TRAFFIC_LIGHTS.length;
  };

  <template>
    <button {{on "click" this.nextLight}}>Next light</button>
    <p>Light is: {{this.light}}</p>
    <p>
      You must
      {{#if (eq this.light "red")}}
        STOP
      {{else if (eq this.light "orange")}}
        SLOW DOWN
      {{else if (eq this.light "green")}}
        GO
      {{/if}}
    </p>
  </template>
}

Lifecycle

On mount

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("page-title")
export class PageTitle extends LitElement {
  @state()
  pageTitle = "";

  connectedCallback() {
    super.connectedCallback();
    this.pageTitle = document.title;
  }

  render() {
    return html`<p>Page title: ${this.pageTitle}</p>`;
  }
}

Ember Polaris

const pageTitle = () => document.title;

<template>
  <p>Page title is: {{(pageTitle)}}</p>
</template>

On unmount

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("x-time")
export class XTime extends LitElement {
  @state()
  time = "";

  timer;

  connectedCallback() {
    super.connectedCallback();
    this.timer = setInterval(() => {
      this.time = new Date().toLocaleTimeString();
    }, 1000);
  }

  disconnectedCallback() {
    super.disconnectedCallback();
    clearInterval(this.timer);
  }

  render() {
    return html`<p>Current time: ${this.time}</p>`;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { registerDestructor } from "@ember/destroyable";

export default class Time extends Component {
  @tracked time = new Date().toLocaleTimeString();

  constructor(owner, args) {
    super(owner, args);

    let timer = setInterval(() => {
      this.time = new Date().toLocaleTimeString();
    }, 1000);

    registerDestructor(this, () => clearInterval(timer));
  }

  <template>
    <p>Current time: {{this.time}}</p>
  </template>
}

Component composition

Props

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";

import "./user-profile";

@customElement("x-app")
export class XApp extends LitElement {
  render() {
    return html`<user-profile
      name="John"
      age="20"
      .favouriteColors=${["green", "blue", "red"]}
      isAvailable
    ></user-profile>`;
  }
}

Ember Polaris

import UserProfile from "./user-profile.gjs";

const favoriteColors = ["green", "blue", "red"];

<template>
  <UserProfile
    @name="John"
    @age={{20}}
    @favouriteColors={{favoriteColors}}
    @isAvailable={{true}}
  />
</template>

Emit to parent

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

import "./answer-button";

@customElement("x-app")
export class XApp extends LitElement {
  @state()
  isHappy = true;

  onAnswerNo() {
    this.isHappy = false;
  }

  onAnswerYes() {
    this.isHappy = true;
  }

  render() {
    return html`
      <p>Are you happy?</p>
      <answer-button
        @yes=${this.onAnswerYes}
        @no=${this.onAnswerNo}
      ></answer-button>
      <p style="font-size: 50px;">${this.isHappy ? "😀" : "😥"}</p>
    `;
  }
}

Ember Polaris

<template>
  <button {{on "click" @onYes}}> YES </button>
  <button {{on "click" @onNo}}> NO </button>
</template>

Slot

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";

import "./funny-button";

@customElement("x-app")
export class XApp extends LitElement {
  render() {
    return html`<funny-button>Click me!</funny-button>`;
  }
}

Ember Polaris

import FunnyButton from "./funny-button";

<template>
  <FunnyButton>Click me!</FunnyButton>
</template>

Slot fallback

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";

import "./funny-button";

@customElement("x-app")
export class XApp extends LitElement {
  render() {
    return html`
      <funny-button></funny-button>
      <funny-button>Click me!</funny-button>
    `;
  }
}

Ember Polaris

import FunnyButton from "./funny-button";

<template>
  <FunnyButton />
  <FunnyButton>I got content!</FunnyButton>
</template>

Context

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";
import { ContextProvider } from "@lit/context";

import { userContext } from "./user-context";

import "./user-profile";

@customElement("x-app")
export class XApp extends LitElement {
  @state()
  user = {
    id: 1,
    username: "unicorn42",
    email: "[email protected]",
  };

  provider = new ContextProvider(this, {
    context: userContext,
    initialValue: this.user,
  });

  updateUsername(newUsername) {
    this.user = { ...this.user, username: newUsername };
    this.provider.setValue(this.user);
  }

  render() {
    return html` <h1>Welcome back, ${this.user.username}</h1>
      <user-profile
        .user="${this.user}"
        .updateUsername=${this.updateUsername.bind(this)}
      ></user-profile>`;
  }
}

Ember Polaris

import UserProfile from "./user-profile";

<template>
    <UserProfile />
</template>

Form input

Input text

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("input-hello")
export class InputHello extends LitElement {
  @state()
  text = "Hello World";

  handleInput(event) {
    this.text = event.target.value;
  }

  render() {
    return html`
      <p>${this.text}</p>
      <input value=${this.text} @input=${this.handleInput} />
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class InputHello extends Component {
  @tracked text = "Hello World";

  handleInput = (event) => (this.text = event.target.value);

  <template>
    <p>{{this.text}}</p>
    <input value={{this.text}} {{on "input" this.handleInput}} />
  </template>
}

Checkbox

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("is-available")
export class IsAvailable extends LitElement {
  @state()
  isAvailable = false;

  handleChange() {
    this.isAvailable = !this.isAvailable;
  }

  render() {
    return html`
      <input
        id="is-available"
        type="checkbox"
        ?checked=${this.isAvailable}
        @change=${this.handleChange}
      />
      <label for="is-available">Is available</label>
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class InputHello extends Component {
  @tracked isAvailable = false;

  handleChange = (event) => (this.isAvailable = event.target.checked);

  <template>
    <input
      id="is-available"
      type="checkbox"
      checked={{this.isAvailable}}
      {{on "change" this.handleChange}}
    />
    <label for="is-available">Is available</label>
  </template>
}

Radio

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";

@customElement("pick-pill")
export class PickPill extends LitElement {
  @state()
  picked = "red";

  handleChange(event) {
    this.picked = event.target.value;
  }

  render() {
    return html`
      <div>Picked: ${this.picked}</div>

      <input
        id="blue-pill"
        name="pill"
        ?checked=${this.picked === "blue"}
        type="radio"
        value="blue"
        @change=${this.handleChange}
      />
      <label for="blue-pill">Blue pill</label>

      <input
        id="red-pill"
        name="pill"
        ?checked=${this.picked === "red"}
        type="radio"
        value="red"
        @change=${this.handleChange}
      />
      <label for="red-pill">Red pill</label>
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class PickPill extends Component {
  @tracked picked = "red";

  handleChange = (event) => (this.picked = event.target.value);

  <template>
    <div>Picked: {{this.picked}}</div>

    <input
      id="blue-pill"
      type="radio"
      value="blue"
      checked={{eq this.picked "blue"}}
      {{on "change" this.handleChange}}
    />
    <label htmlFor="blue-pill">Blue pill</label>

    <input
      id="red-pill"
      type="radio"
      value="red"
      checked={{eq this.picked "red"}}
      {{on "change" this.handleChange}}
    />
    <label htmlFor="red-pill">Red pill</label>
  </template>
}

Select

Lit

import { LitElement, html } from "lit";
import { customElement, state } from "lit/decorators.js";
import { repeat } from "lit/directives/repeat";

@customElement("color-select")
export class ColorSelect extends LitElement {
  colors = [
    { id: 1, text: "red" },
    { id: 2, text: "blue" },
    { id: 3, text: "green" },
    { id: 4, text: "gray", isDisabled: true },
  ];

  @state()
  selectedColorId = 2;

  handleChange(event) {
    this.selectedColorId = event.target.value;
  }

  render() {
    return html`
      <select @change=${this.handleChange}>
        ${repeat(
          this.colors,
          (color) => color.id,
          (color) =>
            html`<option
              value=${color.id}
              ?selected=${this.selectedColorId === color.id}
              ?disabled=${color.isDisabled}
            >
              ${color.text}
            </option>`,
        )}
      </select>
    `;
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

export default class ColorSelect extends Component {
  @tracked selectedColorId = 2;

  select = (event) => (this.selectedColorId = event.target.value);

  isSelected = (colorId) => this.selectedColorId === colorId;

  colors = [
    { id: 1, text: "red" },
    { id: 2, text: "blue" },
    { id: 3, text: "green" },
    { id: 4, text: "gray", isDisabled: true },
  ];

  <template>
    <select {{on "change" this.select}}>
      {{#each this.colors as |color|}}
        <option
          value={{color.id}}
          disabled={{color.isDisabled}}
          selected={{this.isSelected color.id}}
        >
          {{color.text}}
        </option>
      {{/each}}
    </select>
  </template>
}

Webapp features

Render app

Lit

<!doctype html>
<html>
  <head>
    <script type="module" src="./app.js"></script>
  </head>

  <body>
    <x-app />
  </body>
</html>

Ember Polaris

<!doctype html>
<html>
  <body>
    <script type="module" src="./index.js"></script>
  </body>
</html>

Fetch data

Lit

import { LitElement, html } from "lit";
import { customElement } from "lit/decorators.js";
import { createFetchUsersTask } from "./fetch-users-task";

@customElement("x-app")
export class XApp extends LitElement {
  fetchUsers = createFetchUsersTask(this);

  render() {
    return this.fetchUsers.render({
      pending: () => html`<p>Fetching users...</p>`,
      error: (e) => html`<p>An error occurred while fetching users</p>`,
      complete: (data) => html`
        <ul>
          ${data.map(
            (user) => html`
              <li>
                <img src=${user.picture.thumbnail} alt="user" />
                <p>${user.name.first} ${user.name.last}</p>
              </li>
            `,
          )}
        </ul>
      `,
    });
  }
}

Ember Polaris

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";

class State {
  @tracked isLoading = false;
  @tracked error = null;
  @tracked data = null;
}

function fetchUsers() {
  let state = new State();
  
  async function fetchData() {
    try {
      let response = await fetch("https://randomuser.me/api/?results=3");
      let { results: users } = await response.json();
      state.data = users;
      state.error = null;
    } catch (err) {
      state.data = null;
      state.error = err;
    }
    state.isLoading = false;
  }
  
  fetchData();
  return state;
}

export default class App extends Component {
  <template>
    {{#let (this.fetchUsers) as |request|}}
      {{#if request.isLoading}}
        <p>Fetching users...</p>
      {{else if request.error}}
        <p>An error occurred while fetching users</p>
      {{else}}
        <ul>
          {{#each request.data as |user|}}
            <li>
              <img src={{user.picture.thumbnail}} alt="user" />
              <p>{{user.name.first}} {{user.name.last}}</p>
            </li>
          {{/each}}
        </ul>
      {{/if}}
    {{/let}}
  </template>
}

Reactivity #

Declare state #

Lit

Ember Polaris

Update state #

Lit

Ember Polaris

Computed state #

Lit

Ember Polaris

Templating #

Minimal template #

Lit

Ember Polaris

Styling #

Lit

Ember Polaris

Loop #

Lit

Ember Polaris

Event click #

Lit

Ember Polaris

Dom ref #

Lit

Ember Polaris

Conditional #

Lit

Ember Polaris

Lifecycle #

On mount #

Lit

Ember Polaris

On unmount #

Lit

Ember Polaris

Component composition #

Props #

Lit

Ember Polaris

Emit to parent #

Lit

Ember Polaris

Slot #

Lit

Ember Polaris

Slot fallback #

Lit

Ember Polaris

Context #

Lit

Ember Polaris

Form input #

Input text #

Lit

Ember Polaris

Checkbox #

Lit

Ember Polaris

Radio #

Lit

Ember Polaris

Select #

Lit

Ember Polaris

Webapp features #

Render app #

Lit

Ember Polaris

Fetch data #

Lit

Ember Polaris

Reactivity

Declare state

Update state

Computed state

Templating

Minimal template

Styling

Loop

Event click

Dom ref

Conditional

Lifecycle

On mount

On unmount

Component composition

Props

Emit to parent

Slot

Slot fallback

Context

Form input

Input text

Checkbox

Radio

Select

Webapp features

Render app

Fetch data