Lit vs Ember Polaris Comparison

Reactivity

Declare state

Lit

name.js

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 (preview)

name.gjs

import Component from "@glimmer/component";

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

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

Update state

Lit

name.js

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 (preview)

name.gjs

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

double-count.js

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 (preview)

double-count.gjs

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

hello-world.js

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 (preview)

hello-world.gjs

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

Styling

Lit

css-style.js

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 (preview)

css-style.gjs

<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

colors-list.js

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 (preview)

colors.gjs

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

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

Event click

Lit

x-counter.js

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 (preview)

counter.gjs

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

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

input-focused.js

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 (preview)

input-focused.gjs

import { modifier } from "ember-modifier";

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

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

Conditional

Lit

traffic-light.js

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 (preview)

traffic-light.gjs

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { on } from "@ember/modifier";
import { eq } from 'ember-truth-helpers';

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

page-title.js

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 (preview)

page-title.gjs

const pageTitle = () => document.title;

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

On unmount

Lit

x-time.js

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 (preview)

time.gjs

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

x-app.js

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 (preview)

app.gjs

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

x-app.js

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 (preview)

answer-button.gjs

import { on } from "@ember/modifier";

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

Slot

Lit

x-app.js

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 (preview)

app.gjs

import FunnyButton from "./funny-button";

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

Slot fallback

Lit

x-app.js

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 (preview)

app.gjs

import FunnyButton from "./funny-button";

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

Context

Lit

app-x.js

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: "unicorn42@example.com",
  };

  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 (preview)

app.gjs

import UserProfile from "./user-profile";

<template>
  <UserProfile />
</template>

Form input

Input text

Lit

input-hello.js

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 (preview)

input-hello.gjs

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { on } from '@ember/modifier';

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

is-available.js

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 (preview)

is-available.gjs

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { on } from '@ember/modifier';

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

pick-pill.js

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 (preview)

pick-pill.gjs

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { on } from '@ember/modifier';
import { eq } from 'ember-truth-helpers';

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

color-select.js

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 (preview)

color-select.gjs

import Component from "@glimmer/component";
import { tracked } from "@glimmer/tracking";
import { on } from '@ember/modifier';

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

index.html

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

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

Ember Polaris (preview)

index.html

<h1>Hello world</h1>

Fetch data

Lit

x-app.js

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 (preview)

index.html

<div
  x-data="
		function fetchUsers() {
			return {
				users: null,
				isLoading: false,
				error: null,
				async init() {
					this.isLoading = true;
					try {
						this.users = (await (await fetch('https://randomuser.me/api/?results=3')).json()).results;
					} catch (err) {
						this.users = [];
						this.error = err
					}
					this.isLoading = false;
				},
			};
		}
	"
>
  <template x-if="isLoading">
    <p>Loading...</p>
  </template>

  <template x-if="error">
    <p>Error fetching users</p>
  </template>
  <template x-if="!error">
    <ul>
      <template x-for="user in users">
        <li>
          <img
            :src="user.picture.thumbnail"
            :alt="`picture of ${user.name.first} ${user.name.last}`"
          />
          <p x-text="`${user.name.first} ${user.name.last}`"></p>
        </li>
      </template>
    </ul>
  </template>
</div>

Decouvrez plus d’Offres de la plateform ItGalaxy.io :

Découvrez notre gamme complète de services et formations pour accélérer votre carrière.

1. Nous contactez

Description: Besoin de Formation et des Solutions cloud complètes pour vos applications
Links:
- Nous contactez

2. Infra as a Service

Description: Infrastructure cloud évolutive et sécurisée
Links:
- Demandez un devis

3. Projets Développeurs

Description: Découvrez des opportunités passionnantes pour les développeurs
Links:

4. Développeurs

Description: Rejoignez notre communauté de développeurs
Links:
- DevOps
- Web
- Backend
- SEO
- Design
- Mobile
- Wordpress
- Shopify

5. Formations Complètes

Description: Accédez à des formations professionnelles de haute qualité
Links:

6. Marketplace

Description: Découvrez notre place de marché de services
Links:

7. Blogs

Description: Découvrez nos blogs
Links: