Web Components
==============

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
Web Components é uma suíte de diferentes tecnologias que permite a criação de elementos customizados reutilizáveis — com a funcionalidade separada do resto do seu código — e que podem ser utilizados em suas aplicações web.

Conceitos e uso
---------------

Como desenvolvedores, sabemos que é uma boa ideia reutilizar o código o máximo que pudermos. Tradicionalmente, isso não tem sido fácil quando o assunto são estruturas de marcação customizadas — pense no complexo HTML (e estilo e script associados) que, às vezes, deve ser escrito para renderizar controles UI customizados e em como utilizá-los repetidas vezes pode tornar sua página uma bagunça se você não tomar cuidado.

Web Components buscam resolver esses problemas — são formados por três tecnologias principais, que podem ser usadas em conjunto para criar elementos customizados versáteis, com funcionalidade encapsulada, que podem ser reutilizados onde você quiser sem preocupação com conflito de código.

* **Elementos customizados**: Um conjunto de APIs JavaScript que permite definir elementos customizados e seus respectivos comportamentos, podendo ser utilizados de diferentes formas na interface da aplicação.
* **Shadow DOM**: Um conjunto de APIs JavaScript para incorporar uma árvore DOM "fantasma" encapsulada a um elemento — que é renderizada separadamente do DOM do documento principal — e controlar a funcionalidade associada. Nesse caso, você pode manter os recursos de um elemento privados, fazendo com que seu comportamento e estilo possam ser escritos sem medo de causar conflito com outras partes do documento.
* **Templates HTML**: Os elementos `<template>` e `<slot>` (en-US) permitem que você escreva templates de marcação que não são exibidas na página. Elas podem então ser reutilizadas várias vezes como modelo de estrutura de um elemento customizado.

A abordagem básica para se implementar um componente web geralmente se parece com isso:

1. Crie uma classe na qual você especifica a funcionalidade do seu componente web, usando a sintaxe de classe do ECMAScript 2015 (veja Classes para mais informações).
2. Registre seus elemento customizado através do método `CustomElementRegistry.define()`, passando o nome do elemento a ser definido, a classe ou função na qual sua funcionalidade foi especificada, e opcionalmente, de qual elemento ele herda suas propriedades.
3. Se necessário, incorpore um shadow DOM ao elemento customizado usando o método `Element.attachShadow()` (en-US). Adicione elementos filhos, listeners, etc., ao shadow DOM usando métodos normais de DOM.
4. Se necessário, defina um template HTML usando `<template>` e `<slot>` (en-US). Novamente, use os métodos normais de DOM methods para clonar o template e inclui-la ao shadow DOM.
5. Use seu elemento customizado onde você preferir em sua página, da mesma forma que usaria qualquer outro elemento HTML.
Tutoriais
---------

Usando elementos customizados

Um guia que mostra como usar os recursos de elementos customizados para criar componentes web simples, além de como analisar o ciclo de vida das funções de retorno e outros recursos mais avançados.

Usando shadow DOM (en-US)

Um guia que analisa os fundamentos do shadow DOM, mostrando como incorporá-lo a um elemento, adicioná-lo à árvore do shadow DOM, estilizá-lo, etc.

Usando templates e slots (en-US)

Um guia que mostra como definir uma estrutura HTML reutilzável através dos elementos `<template>` e `<slot>` (en-US), e como utilizar essa estrutura dentro de elementos web.

Referência
----------

### Elementos customizados

`CustomElementRegistry`

Contém funcionalidade relacionada a elementos personalizados, principalmente o método `CustomElementRegistry.define()` usado para registrar novos elementos personalizados, para que possam ser usados em seu documento.

`Window.customElements` (en-US)

Retorna uma referência ao objeto `CustomElementRegistry`.

Callbacks do ciclo de vida

Funções callback especiais definidas dentro da definição de classe de elemento customizado, afetando seu comportamento:

* `connectedCallback`: Invocada quando um elemento customizado é adicionao ao DOM do documento.
* `disconnectedCallback`: Invocada quando o elemento customizado é desconectado do DOM do documento.
* `adoptedCallback`: Invocada quando o elemento customizado é movido para um novo documento.
* `attributeChangedCallback`: Invocada quando um dos atributos de um elemento customizado é adicionado, removido ou alterado.

Extensões para criação de elementos built-in customizados

The following extensions are defined:

* O atributo HTML global `is`: Permite especificar que um elemento HTML padrão deve se comportar como um elemento built-in customizado registrado.
* A opção "is" do método `Document.createElement()`: Permite criar uma instância de um elemento HTML standard que se comporta como um determinado elemento built-in customizado registrado.

CSS pseudo-classes

Pseudo-classes relacionadas especificamente a elementos customizados:

* `:defined` (en-US): Corresponde a qualquer elemento que está definido, incluindo elementos built-in e elementos customizados que foram definidos com `CustomElementRegistry.define()`).
* `:host` (en-US): Seleciona o host fantasma do shadow DOM (en-US) contendo o CSS utilizado internamente.
* `:host()` (en-US): Seleciona o host fantasma do shadow DOM (en-US) contendo o CSS utilizado internamente (permitindo selecionar um elemento customizado de dentro de seu shadow DOM) — mas somente se o seletor que foi passado via parâmetro da função corresponder ao host fantasma.
* `:host-context()`: Seleciona o host fantasma do shadow DOM (en-US) contendo o CSS utilizado internamente (permitindo selecionar um elemento customizado de dentro de seu shadow DOM) — mas somente se o seletor que foi passado via parâmetro da função corresponder ao(s) ancestral(ais) do host fantasma relativo à posição que ele toma dentro da hierarquida do DOM.

CSS pseudo-elementos

Pseudo-elementos relacionados especificamente a elementos customizados:

* `::part` (en-US): Representa qualquer elemento dentro de uma shadow tree (en-US) que tenha um atributo `part` correspondente.

### Shadow DOM

`ShadowRoot` (en-US)

Representa o nó raíz de uma sub-árvore DOM fantasma.

`DocumentOrShadowRoot`

Um mixin que define funcionalidades que ficam disponíveis através do documento e das raízes fantasma.

Extensões `Element`

Extensões à interface `Element` relacionado ao shadow DOM:

* O método `Element.attachShadow()` (en-US) vincula uma árvore DOM fantasma ao elemento especificado.
* A propriedade `Element.shadowRoot` (en-US) retorna a árvore fantasma raíz vinculada ao elemento especificado, ou `null` se não existir nenhuma árvore fantasma vinculada.

Adições relevantes `Node`

Adicionais à interface `Node` pertinentes ao shadow DOM:

* O método `Node.getRootNode()` (en-US) retorna a raíz do objeto contexto, que opcionalmente inclui a "raíz fantasma" (shadow root) se a mesma estiver dispinível.
* A propriedade `Node.isConnected` retorna um boolean indicando se o Nó está ou não conectado (direta ou indiretamente) ao objeto contexto, ex. o objeto `Document` no caso de um DOM normal, ou o `ShadowRoot` (en-US) no caso de um DOM fantasma (shadow DOM).

Extensões `Event`

Extensões para a interface de `Event` relacionado a shadow DOM:

* `Event.composed` (en-US): Retorna um `Boolean` que indica
 se o evento irá se propagar através dos limites do shadow DOM para dentro do DOM padrão (`true`), ou não (`false`).
* `Event.composedPath` (en-US): Retorna o caminho do evento (objetos nos quais os listeners serão invocados). Não inclui nós na shadow tree se a shadow root foi criada com `ShadowRoot.mode` (en-US) closed (fechado).

### Templates HTML

`<template>`

Contém um fragmento HTML que não é renderizado quando um documento que o contém é inicialmente carregado, mas pode ser exibido em tempo de execução usando JavaScript, geralmente utilizado como base de estruturas de elementos customizados. A interface DOM associada é `HTMLTemplateElement` (en-US).

`<slot>` (en-US)

Um placeholder dentro de um web component que você pode preencher com seu texto de marcação, permitindo criar árvores DOM separadas e apresentar delas juntas. A interface DOM associada é a `HTMLSlotElement`.

`O atributo HTML global slot`

Atribui um slot em uma árvore shadow DOM a um elemento.

`Slotable` (en-US)

Um mixin implementado por ambos os nós `Element` e`Text` (en-US) definindo funcionalidades que permitem tornar-se conteúdo de um elemento `<slot>` (en-US). O mixin define um atributo, `Slotable.assignedSlot` (en-US), o qual retorna uma referência do slot em que o nó está sendo inserido.

Extensões `Element`

Extensões para a interface de `Element` relacionado a slots:

* `Element.slot` (en-US): Retorna o nome do slot do shadow DOM associado ao elemento.

Pseudo-elementos CSS

Pseudo-elementos relacionados especificamente a slots:

* `::slotted` (en-US): Corresponde a qualquer conteúdo inserido naquele slot.

O evento `slotchange`

Disparado em uma instância `HTMLSlotElement` (elemento `<slot>` (en-US)) quando há mudança no nó(s) contido naquele slot.

Exemplos
--------

 Estamos construindo alguns exemplos em nosso repo do GitHub web-components-examples.
 Mais exemplos serão adicionados com o passar do tempo.

Especificações
--------------

| Specification |
| --- |
| HTML Standard # the-template-element |
| DOM Standard # interface-shadowroot |

Compatibilidade com navegadores
-------------------------------

### html.elements.template

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

### api.ShadowRoot

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* webcomponents.org — site apresentando exemplos de web components, tutoriais e outras informações.
* FAST é uma biblioteca de web component construída pela Microsoft que oferece vários pacotes para potencializar dependendo das necessidades do seu projeto. Fast Element é um meio fácil de criar Web Components de alto desempenho, com eficiência de memória e em conformidade com os padrões. Fast Foundation é uma biblioteca de classes, modelos e outros utilitários de Web Components criados em elementos rápidos destinados a serem compostos em Web Components registrados.
* Hybrids — Biblioteca web components de código aberto, que favorece objetos simples e funções puras em vez de `class` e this sintaxe. Ele fornece uma API simples e funcional para a criação de elementos personalizados.
* Polymer — Framework de web components do Google - um conjunto de polyfills, melhorias e exemplos. Atualmente, a maneira mais fácil de usar os web components em vários navegadores.
* Snuggsi — Web Components fáceis com ~1kB *Incluindo polyfill* — Tudo que você precisa é um navegador e um conhecimento básico de HTML, CSS e classes JavaScript para ser produtivo.
* Slim.js — Biblioteca web components de código aberto - uma biblioteca de alto desempenho para criação rápida e fácil de componentes; extensível e plugável e compatível com cross-framework.
* Stencil — Conjunto de ferramentas para a construção de sistemas de design reutilizáveis e escalonáveis em web components.