WU / DOCSMICROFRONTENDS UNIVERSAIS
PT
REFERÊNCIA DE APIS44 MIN DE LEITURA · MARKDOWN ↗

Referência de adaptadores e bindings

Registro de treze tecnologias, adapters personalizados, slots, hooks, stores reativos e helpers de IA.

Veja versões, mudanças e requisitos em Framework 4.0 e CLI 1.2.

Um contrato comum com capacidades por framework

Cada subpath wu-framework/adapters/<framework> exporta register e utilitários próprios. Importe o adaptador que você realmente usa. wu-framework/adapters reúne aliases como registerReact, registerVue e createVueUseWuAI; os objetos wuReact, wuVue e equivalentes agrupam as mesmas funções, e seus exports default são essa mesma família de utilitários.

Um registro true indica que o lifecycle foi definido ou que a montagem standalone terminou. register() aguarda essa montagem e rejeita se ela falhar. Em um shell, registre pelo entrypoint da microapp e aguarde wu.mount; os lifecycles dos adapters são assíncronos.

As factories de hooks são criadas fora do render e usadas dentro do componente correspondente. Imports de Card, Root e outros componentes de exemplo representam módulos da sua aplicação, já compilados pelo framework. Cada entrada especifica sua limpeza e contrato no 4.0.0.

Os hooks de eventos e store resolvem a facade da app montada. Só usam o runtime global fora de uma montagem WU. getWuInstance() continua retornando o host, e os helpers de IA continuam usando seu wu.ai. Consulte integrações e permissões de composição.

loadAdapter

Carrega e memoriza o módulo de um adaptador pelo nome.

loadAdapter(name): Promise<AdapterModule>

  • Parâmetros: Um dos ADAPTER_NAMES; nomes em minúsculas.
  • Retorno: Objeto do adapter (wuReact, wuVue ou equivalente); compartilha a promessa de uma carga em andamento.
  • Erros: Nome desconhecido ou import malsucedido rejeitam a promessa. Um carregamento malsucedido libera sua promessa para permitir uma nova tentativa.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: O módulo importado permanece no cache do processo.
import { loadAdapter } from 'wu-framework/adapters';
const { register } = await loadAdapter('react');

Referência: src/adapters/index.js.

ADAPTER_NAMES

Enumera os adaptadores carregáveis a partir do barrel.

ADAPTER_NAMES: readonly string[]

  • Parâmetros: Constante congelada.
  • Retorno: Lista de nomes.
  • Erros: Leitura sem efeitos.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Não exige limpeza.
import { ADAPTER_NAMES } from 'wu-framework/adapters';
console.log(ADAPTER_NAMES);

Referência: src/adapters/index.js.

getWuInstance

Procura WU na janela atual e em parent e top acessíveis.

getWuInstance(): WuCore | null

  • Parâmetros: Exportado por shared e pelos adaptadores.
  • Retorno: Instância encontrada ou null.
  • Erros: Captura acessos cross-origin a parent/top; não lança por causa deles.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Não cria inscrições.
import { getWuInstance } from 'wu-framework/adapters/shared';
const wu = getWuInstance();

Referência: src/adapters/shared.js.

waitForWu

Aguarda uma instância global com eventos ready e sondagem.

waitForWu(timeout?): Promise<WuCore | null>

  • Parâmetros: Tempo em ms, 5000 por padrão.
  • Retorno: Instância encontrada; um evento ready externo sem instância pode resolver para null.
  • Erros: Rejeita ao esgotar o timeout; precisa de window.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: O helper remove os listeners e o temporizador ao resolver ou rejeitar.
import { waitForWu } from 'wu-framework/adapters/shared';
const wu = await waitForWu(3000);
if (!wu) throw new Error('No hay runtime disponible');

Referência: src/adapters/shared.js.

createWuAdapter

Constrói um adaptador personalizado com estado de montagem e props por aplicação.

createWuAdapter(config): register

  • Parâmetros: mount e unmount obrigatórios; name, ensure, update, hydrate, defineTimeout opcionais. A função resultante recebe appName, Component, options.
  • Retorno: Função assíncrona de registro que retorna boolean.
  • Erros: Lança se mount/unmount estiverem ausentes; ensure:false produz false.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { createWuAdapter } from 'wu-framework/adapters/shared';
const register = createWuAdapter({
  mount(container, { Component, props }) { return Component(container, props); },
  unmount(_container, { instance }) { instance?.dispose?.(); },
});
await register('plain', (container) => {
  container.textContent = 'Hola';
  return { dispose() { container.replaceChildren(); } };
}, { standalone: false });

Não inclui uma política própria de permissões. O container e o ciclo de vida vêm do WU.

Referência: src/adapters/shared.js.

react.register

Registra uma aplicação React por meio dos callbacks que o WU entende.

register(appName, Component, options?): Promise<boolean>

  • Parâmetros: strictMode true, props, onMount/onUnmount, standalone true, standaloneContainer #root, runtime:{React,ReactDOM} opcional.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/react';
import React from 'react';
import * as ReactDOM from 'react-dom/client';
await register('card', Card, { runtime: { React, ReactDOM }, props: { count: 1 }, standalone: false });

React deve usar createRoot; para hidratação, precisa de hydrateRoot na mesma instância.

Referência: src/adapters/react/index.js.

vue.register

Registra uma aplicação Vue por meio dos callbacks que o WU entende.

register(appName, RootComponent, options?): Promise<boolean>

  • Parâmetros: props, setup(app), onMount/onUnmount, standalone true, standaloneContainer #app.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/vue';
await register('card', Card, { props: { count: 1 }, standalone: false });

Vue atualiza as props da instância filha montada ou hidratada por um wrapper reativo, preservando keep-alive.

Referência: src/adapters/vue/index.js.

angular.register

Registra uma aplicação Angular por meio dos callbacks que o WU entende.

register(appName, AppModule, options?): Promise<boolean>

  • Parâmetros: platformFactory, providers, rootSelector app-root, standalone e callbacks.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/angular';
await register('card', AppModule, { rootSelector: 'card-root', standalone: false });

Para componentes standalone, use registerStandalone. Esse registro cria e destrói a plataforma e o módulo Angular.

Referência: src/adapters/angular/index.js.

svelte.register

Registra uma aplicação Svelte por meio dos callbacks que o WU entende.

register(appName, Component, options?): Promise<boolean>

  • Parâmetros: props, context Map, intro false, standalone true, standaloneContainer #app e callbacks.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/svelte';
await register('card', Card, { props: { count: 1 }, standalone: false });

Esse registro usa o construtor, $set e $destroy do modelo Svelte 4. Use registerSvelte5 para a API moderna.

Referência: src/adapters/svelte/index.js.

preact.register

Registra uma aplicação Preact por meio dos callbacks que o WU entende.

register(appName, Component, options?): Promise<boolean>

  • Parâmetros: props, callbacks, standalone true e standaloneContainer #app.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/preact';
await register('card', Card, { props: { count: 1 }, standalone: false });

Acrescenta wuAppName e wuInstance às props; update renderiza novamente com as props mescladas.

Referência: src/adapters/preact/index.js.

solid.register

Registra uma aplicação Solid por meio dos callbacks que o WU entende.

register(appName, Component, options?): Promise<boolean>

  • Parâmetros: props, callbacks, standalone true e standaloneContainer #root.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/solid';
await register('card', Card, { props: { count: 1 }, standalone: false });

O registro exige solid-js/web. Não pressupõe o mesmo contrato update/hydrate de React.

Referência: src/adapters/solid/index.js.

lit.register

Registra uma aplicação Lit por meio dos callbacks que o WU entende.

register(appName, ElementClass, options?): Promise<boolean>

  • Parâmetros: tagName, properties, callbacks, standalone true e standaloneContainer #root.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/lit';
await register('card', CardElement, { tagName: 'demo-card', properties: { count: 1 }, standalone: false });

O custom element permanece em customElements após a desmontagem: o registro global não pode ser desfeito.

Referência: src/adapters/lit/index.js.

vanilla.register

Registra uma aplicação vanilla por meio dos callbacks que o WU entende.

register(appName, config, options?): Promise<boolean>

  • Parâmetros: config.render obrigatório, init/destroy/state opcionais; options do adaptador compartilhado.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/vanilla';
await register('card', {
  state: { count: 1 },
  render(container, state) { container.textContent = String(state.count); },
}, { standalone: false });

Seu render controla o conteúdo do contêiner e seu destroy libera os recursos externos.

Referência: src/adapters/vanilla/index.js.

alpine.register

Registra uma aplicação Alpine por meio dos callbacks que o WU entende.

register(appName, appConfig, options?): Promise<boolean>

  • Parâmetros: template e data(); runtime Alpine e dataName podem estar em config ou options; standalone/callbacks.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/alpine';
await register('card', {
  template: '<section x-data="__WU_ALPINE_DATA__"><b x-text="count"></b></section>',
  data: () => ({ count: 1 }),
}, { runtime: Alpine, standalone: false });

Sem runtime Alpine, insere HTML e avisa; um registro true não certifica que os atributos Alpine funcionem.

Referência: src/adapters/alpine/index.js.

qwik.register

Registra uma aplicação Qwik por meio dos callbacks que o WU entende.

register(appName, Component, options?): Promise<boolean>

  • Parâmetros: props e runtime; o runtime pode ser Qwik 1 ou Qwik 2. Não aceita base, createProps, loadQwikLoader nem opções standalone.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/qwik';
await register('card', Card, { props: { count: 1 } });

O adapter prefere @qwik.dev/core, depois @builder.io/qwik; carrega o qwikloader correspondente à versão do runtime. A prop wu usa noSerialize e contém a facade da app.

Referência: src/adapters/qwik/index.js.

stencil.register

Registra uma aplicação Stencil por meio dos callbacks que o WU entende.

register(appName, tagName, options?): Promise<boolean>

  • Parâmetros: props para valores JavaScript, attributes para strings, callbacks e standalone.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/stencil';
await register('card', 'demo-card', { props: { count: 1 }, attributes: { label: 'Resumen' }, standalone: false });

Registre previamente os custom elements do bundle Stencil; este helper cria a tag, mas não carrega sua definição.

Referência: src/adapters/stencil/index.js.

htmx.register

Registra uma aplicação HTMX por meio dos callbacks que o WU entende.

register(appName, config, options?): Promise<boolean>

  • Parâmetros: template obrigatório; baseUrl, setup(container,htmx); runtime e opções standalone/callbacks.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/htmx';
await register('card', {
  template: '<button hx-get="/fragment">Actualizar</button>',
  baseUrl: '/api',
}, { runtime: htmx, standalone: false });

Reescreve caminhos hx-* que começam com /, concatenando baseUrl. Sem htmx, insere HTML sem ativar solicitações. setup pode retornar cleanup.

Referência: src/adapters/htmx/index.js.

stimulus.register

Registra uma aplicação Stimulus por meio dos callbacks que o WU entende.

register(appName, config, options?): Promise<boolean>

  • Parâmetros: template e mapa controllers não vazio; callbacks e standalone.
  • Retorno: true se define o lifecycle ou realiza o fallback standalone; false quando não consegue concluir o registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { register } from 'wu-framework/adapters/stimulus';
await register('card', {
  template: '<section data-controller="counter"></section>',
  controllers: { counter: CounterController },
}, { standalone: false });

Cria uma Application de Stimulus para a subárvore e a interrompe ao desmontar.

Referência: src/adapters/stimulus/index.js.

angular.registerStandalone

Monta um componente standalone de Angular com um host dentro do contêiner do WU.

registerStandalone(appName, RootComponent, options?): Promise<boolean>

  • Parâmetros: appConfig, createApplication, createComponent, provideZoneChangeDetection, callbacks e standalone.
  • Retorno: Boolean de registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { registerStandalone } from 'wu-framework/adapters/angular';
import { createApplication } from '@angular/platform-browser';
import { createComponent } from '@angular/core';
await registerStandalone('card', Card, { createApplication, createComponent, standalone: false });

As props iniciais e wu.update() são aplicadas aos inputs da instância Angular.

Referência: src/adapters/angular/index.js.

angular.registerElement

Expõe um componente Angular por meio de Angular Elements.

registerElement(appName, Component, options?): Promise<boolean>

  • Parâmetros: elementTag, appConfig, callbacks, standalone e standaloneContainer.
  • Retorno: Boolean de registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { registerElement } from 'wu-framework/adapters/angular';
await registerElement('card', Card, { elementTag: 'angular-card', standalone: false });

Exige @angular/elements. Remover o elemento não cancela o registro de seu construtor global.

Referência: src/adapters/angular/index.js.

svelte.registerSvelte5

Usa mount/unmount de Svelte 5, com fallback para a API anterior de componentes.

registerSvelte5(appName, Component, options?): Promise<boolean>

  • Parâmetros: props, onMount, onUnmount e opções standalone. Não aceita createProps.
  • Retorno: Boolean de registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { registerSvelte5 } from 'wu-framework/adapters/svelte';
await registerSvelte5('card', Card, { props: { count: 1 }, standalone: false });

registerSvelte5 registra mount/unmount e não oferece um slot update. Use um store compartilhado para dados vivos; não espere que wu.update() altere as props do componente registrado por essa função.

Referência: src/adapters/svelte/index.js.

preact.registerCompat

Renderiza com preact/compat e recorre ao adaptador Preact quando não consegue importá-lo.

registerCompat(appName, Component, options?): Promise<boolean>

  • Parâmetros: props, callbacks e standalone.
  • Retorno: Boolean de registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { registerCompat } from 'wu-framework/adapters/preact';
await registerCompat('card', Card, { standalone: false });

O caminho compat registra mount/unmount; não equivale ao canal update de register normal.

Referência: src/adapters/preact/index.js.

lit.registerWebComponent

Reutiliza o registro Lit para uma classe HTMLElement sem dependência de Lit.

registerWebComponent(appName, ElementClass, options?): Promise<boolean>

  • Parâmetros: Classe custom element e as mesmas options de register Lit.
  • Retorno: Boolean de registro.
  • Erros: Um registro pode retornar false se o WU ou o framework não estiverem disponíveis; também captura erros do renderer durante mount.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Desmonte por meio de wu.unmount(appName) para executar o cleanup do framework; guarde e cancele suas próprias inscrições.
import { registerWebComponent } from 'wu-framework/adapters/lit';
class Card extends HTMLElement { connectedCallback() { this.textContent = 'Hola'; } }
await registerWebComponent('card', Card, { tagName: 'plain-card', standalone: false });

Referência: src/adapters/lit/index.js.

react.createUseWuEvents

Cria um hook de eventos vinculado ao ciclo de vida do componente.

createUseWuEvents(React): () => EventsHelper

  • Parâmetros: Namespace React com os hooks exigidos. O helper retorna emit, on e once.
  • Retorno: Hook que retorna funções de publicação e inscrição.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: As inscrições criadas com on são removidas ao desmontar; guarde também o disposer de once se ele puder ficar pendente.
import React from 'react';
import { createUseWuEvents } from 'wu-framework/adapters/react';
const useWuEvents = createUseWuEvents(React);
function View() {
  const events = useWuEvents();
  return null;
}

Referência: src/adapters/react/index.js.

react.createUseWuStore

Cria um hook que reflete um caminho do store no estado do componente.

createUseWuStore(React): (namespace?) => StoreHelper

  • Parâmetros: Namespace de hooks; o hook aceita um prefixo de estado, vazio para a raiz.
  • Retorno: Objeto {state,setState,getState}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import React from 'react';
import { createUseWuStore } from 'wu-framework/adapters/react';
const useWuStore = createUseWuStore(React);
function View() {
  const { state, setState } = useWuStore('cart');
  return null;
}

Referência: src/adapters/react/index.js.

react.createWuSlot

Cria um componente que hospeda uma app WU por nome e URL.

createWuSlot(React): WuSlotComponent

  • Parâmetros: Nome do framework e hooks; props name, url, appName, fallback e callbacks.
  • Retorno: Componente para renderizar um slot.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import React from 'react';
import { createWuSlot } from 'wu-framework/adapters/react';
const WuSlot = createWuSlot(React);
const element = React.createElement(WuSlot, { name: 'card', url: '/apps/card' });

Referência: src/adapters/react/index.js.

preact.createUseWuEvents

Cria um hook de eventos vinculado ao ciclo de vida do componente.

createUseWuEvents(hooks): () => EventsHelper

  • Parâmetros: Namespace hooks com os hooks exigidos. O helper retorna emit, on e once.
  • Retorno: Hook que retorna funções de publicação e inscrição.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: As inscrições criadas com on são removidas ao desmontar; guarde também o disposer de once se ele puder ficar pendente.
import * as hooks from 'preact/hooks';
import { createUseWuEvents } from 'wu-framework/adapters/preact';
const useWuEvents = createUseWuEvents(hooks);
function View() {
  const events = useWuEvents();
  return null;
}

Referência: src/adapters/preact/index.js.

preact.createUseWuStore

Cria um hook que reflete um caminho do store no estado do componente.

createUseWuStore(hooks): (namespace?) => StoreHelper

  • Parâmetros: Namespace de hooks; o hook aceita um prefixo de estado, vazio para a raiz.
  • Retorno: Objeto {state,setState,getState}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import * as hooks from 'preact/hooks';
import { createUseWuStore } from 'wu-framework/adapters/preact';
const useWuStore = createUseWuStore(hooks);
function View() {
  const { state, setState } = useWuStore('cart');
  return null;
}

Referência: src/adapters/preact/index.js.

preact.createWuSlot

Cria um componente que hospeda uma app WU por nome e URL.

createWuSlot(h, hooks?): WuSlotComponent

  • Parâmetros: Função h de Preact e objeto de hooks useState/useEffect/useRef. Sem hooks, retorna uma versão básica com menos comportamento.
  • Retorno: Componente para renderizar um slot.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { h } from 'preact';
import * as hooks from 'preact/hooks';
import { createWuSlot } from 'wu-framework/adapters/preact';
const WuSlot = createWuSlot(h, hooks);

Referência: src/adapters/preact/index.js.

vue.useWuEvents

Fornece utilitários de eventos e uma limpeza explícita.

useWuEvents(): EventsHelper

  • Parâmetros: Sem argumentos.
  • Retorno: {emit,on,once,off,cleanup}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame cleanup a partir de onUnmounted e guarde os canceladores de once quando necessário.
import { useWuEvents } from 'wu-framework/adapters/vue';
import { onUnmounted } from 'vue';
const events = useWuEvents();
events.on('cart:changed', console.log);
onUnmounted(events.cleanup);

Referência: src/adapters/vue/index.js.

vue.useWuStore

Reflete um caminho do store em um ref de Vue quando o adaptador tem o runtime disponível.

useWuStore(namespace?): StoreHelper

  • Parâmetros: Namespace opcional.
  • Retorno: {state,setState,getState,cleanup}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame cleanup ao desmontar.
import * as Vue from 'vue';
import { useWuStore, wuVuePlugin } from 'wu-framework/adapters/vue';
app.use(wuVuePlugin, { Vue });
const cart = useWuStore('cart');
Vue.onUnmounted(cart.cleanup);

O runtime Vue deve estar configurado; não interpreta padrões namespace.* como observação de descendentes arbitrários.

Referência: src/adapters/vue/index.js.

vue.wuVuePlugin

Instala WuSlot, utilitários globais e a instância de Vue usada pelo adaptador.

app.use(wuVuePlugin, options?): app

  • Parâmetros: options.Vue permite passar o namespace Vue do host.
  • Retorno: O resultado de app.use de Vue.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: O host desmonta a aplicação Vue; limpe os listeners próprios de seus componentes.
import * as Vue from 'vue';
import { wuVuePlugin } from 'wu-framework/adapters/vue';
const app = Vue.createApp(Root);
app.use(wuVuePlugin, { Vue });

Referência: src/adapters/vue/index.js.

vue.WuSlot

Expõe o componente Vue que monta uma aplicação WU.

WuSlot: Vue component options

  • Parâmetros: Props name, url, appName e fallbackText; runtime Vue disponível.
  • Retorno: Objeto de definição de componente.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { WuSlot } from 'wu-framework/adapters/vue';
const components = { WuSlot };

WuSlot opera no ciclo de vida de Vue; não representa o WuApp do subpath Next.

Referência: src/adapters/vue/index.js.

svelte.createWuStore

Cria um store compatível com subscribe de Svelte conectado ao WU.

createWuStore(namespace?): SvelteStore

  • Parâmetros: Prefixo do caminho; vazio observa a raiz.
  • Retorno: {subscribe,set,get,update}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Ao cancelar o último subscriber, a inscrição WU é removida; uma nova inscrição volta a conectá-la.
import { createWuStore } from 'wu-framework/adapters/svelte';
const cart = createWuStore('cart');
const stop = cart.subscribe(value => console.log(value));
stop();

Referência: src/adapters/svelte/index.js.

svelte.createWuEventStore

Expõe o último evento como um store que aceita inscrições.

createWuEventStore(eventPattern): EventStore

  • Parâmetros: Padrão reconhecido pelo barramento de eventos.
  • Retorno: {subscribe,emit}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Cancelar o último subscriber desconecta o listener WU.
import { createWuEventStore } from 'wu-framework/adapters/svelte';
const changes = createWuEventStore('cart:changed');
const stop = changes.subscribe(console.log);
stop();

Referência: src/adapters/svelte/index.js.

svelte.useWuEvents

Fornece emit/on/once/off com limpeza manual para componentes Svelte.

useWuEvents(): EventsHelper

  • Parâmetros: Sem argumentos.
  • Retorno: {emit,on,once,off,cleanup}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Invoque cleanup a partir de onDestroy; a função não registra esse lifecycle por você.
import { onDestroy } from 'svelte';
import { useWuEvents } from 'wu-framework/adapters/svelte';
const events = useWuEvents();
onDestroy(events.cleanup);

Referência: src/adapters/svelte/index.js.

svelte.createWuSlotConfig

Retorna um template e uma configuração para construir um slot Svelte.

createWuSlotConfig(): SlotConfig

  • Parâmetros: Sem argumentos.
  • Retorno: {props,template,createInstance}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { createWuSlotConfig } from 'wu-framework/adapters/svelte';
const config = createWuSlotConfig();
console.log(config.props, config.template);

É uma configuração com texto-fonte de componente; não é um componente compilado nem uma função que renderiza sozinha.

Referência: src/adapters/svelte/index.js.

solid.createWuStore

Conecta um caminho do WU a um signal de Solid.

createWuStore(namespace?): [accessor, setter]

  • Parâmetros: Namespace; deve ser executado em um owner de Solid com runtime disponível.
  • Retorno: Tupla de accessor de estado e função setWuState(path,value).
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Registra o unsubscribe no onCleanup do owner Solid.
import { createWuStore } from 'wu-framework/adapters/solid';
function View() {
  const [cart, setCart] = createWuStore('cart');
  setCart('count', 1);
  return null;
}

Referência: src/adapters/solid/index.js.

solid.createWuEvent

Reflete o último evento em um signal.

createWuEvent(pattern): accessor

  • Parâmetros: Padrão do barramento.
  • Retorno: Accessor que retorna o evento ou null inicialmente.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Registra unsubscribe por meio de onCleanup.
import { createWuEvent } from 'wu-framework/adapters/solid';
function View() {
  const latest = createWuEvent('cart:changed');
  return null;
}

Referência: src/adapters/solid/index.js.

solid.useWuEvents

Fornece utilitários de eventos dentro de um owner Solid.

useWuEvents(): EventsHelper

  • Parâmetros: Sem argumentos.
  • Retorno: {emit,on,once,off}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { useWuEvents } from 'wu-framework/adapters/solid';
function View() { const events = useWuEvents(); return null; }

Referência: src/adapters/solid/index.js.

solid.createWuContext

Cria um contexto de Solid para compartilhar a instância WU.

createWuContext(): { WuProvider, useWu, WuContext }

  • Parâmetros: Sem argumentos; precisa do runtime Solid disponível.
  • Retorno: Provider, hook e contexto.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: O contexto não abre transporte nem recursos persistentes.
import { createWuContext } from 'wu-framework/adapters/solid';
const { WuProvider, useWu } = createWuContext();

Referência: src/adapters/solid/index.js.

solid.createWuSlot

Cria o componente de slot de Solid.

createWuSlot(): WuSlotComponent

  • Parâmetros: Sem argumentos; o componente recebe name, url, appName, fallback e callbacks.
  • Retorno: Função de componente.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { createWuSlot } from 'wu-framework/adapters/solid';
const WuSlot = createWuSlot();

Referência: src/adapters/solid/index.js.

angular.createWuService

Fornece funções de eventos e estado para um serviço Angular.

createWuService(): WuService

  • Parâmetros: Sem argumentos.
  • Retorno: emit,on,once,off,getState,setState,onStateChange,destroy e getter wu.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame destroy a partir de ngOnDestroy; as inscrições de once devem ser canceladas se continuarem pendentes.
import { createWuService } from 'wu-framework/adapters/angular';
const service = createWuService();
service.on('cart:changed', console.log);
service.destroy();

getState converte valores falsy em null. Para preservar false, 0 ou uma string vazia dentro da app, use inject(WuAppScope).wu.store.get(path) em um contexto DI. service.wu retorna o host e não deve ser usado para contornar grants.

Referência: src/adapters/angular/index.js.

angular.createWuSlotComponent

Retorna metadados e métodos base para implementar um slot Angular.

createWuSlotComponent(): ComponentConfig

  • Parâmetros: Sem argumentos.
  • Retorno: Objeto selector, template, styles e methods.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { createWuSlotComponent } from 'wu-framework/adapters/angular';
const config = createWuSlotComponent();
console.log(config.selector, config.methods);

Não retorna uma classe já decorada por @Component. Você deve integrar os metadados, ViewChild e métodos em uma classe Angular.

Referência: src/adapters/angular/index.js.

angular.getWuSlotModuleConfig

Descreve os nomes do módulo que hospeda um slot Angular.

getWuSlotModuleConfig(): object

  • Parâmetros: Sem argumentos.
  • Retorno: {imports,declarations,exports} com nomes string.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { getWuSlotModuleConfig } from 'wu-framework/adapters/angular';
console.log(getWuSlotModuleConfig());

São nomes descritivos; não são referências de classes para passar diretamente a @NgModule.

Referência: src/adapters/angular/index.js.

lit.createWuSlotElement

Cria uma classe Lit que hospeda um slot WU.

createWuSlotElement(LitElement, html, css?): ElementClass

  • Parâmetros: Primitivas da mesma instância Lit do host.
  • Retorno: Classe de custom element para registrar.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { LitElement, html, css } from 'lit';
import { createWuSlotElement } from 'wu-framework/adapters/lit';
customElements.define('demo-wu-slot', createWuSlotElement(LitElement, html, css));

O core monta por seletor de documento; verifique a estratégia DOM do slot e a versão antes de hospedá-lo dentro de outro shadow root.

Referência: src/adapters/lit/index.js.

lit.WuMixin

Acrescenta wuEmit/wuOn/wuOnce e acesso ao store a uma classe de elemento.

WuMixin(Base): subclass

  • Parâmetros: Classe base HTMLElement ou LitElement.
  • Retorno: Subclasse com métodos WU e cleanup em disconnectedCallback.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame super.disconnectedCallback ao sobrescrevê-lo para executar a limpeza do mixin.
import { LitElement } from 'lit';
import { WuMixin } from 'wu-framework/adapters/lit';
class Card extends WuMixin(LitElement) {
  connectedCallback() { super.connectedCallback(); this.wuOn('cart:changed', console.log); }
}

Referência: src/adapters/lit/index.js.

lit.wuProperty

Conecta uma propriedade do elemento a um caminho do store.

wuProperty(storePath): legacy property decorator

  • Parâmetros: Caminho string; decorador legacy aplicado ao prototype e ao nome da propriedade.
  • Retorno: Função decoradora que instala getter/setter e hooks de conexão.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { wuProperty } from 'wu-framework/adapters/lit';
wuProperty('cart.count')(Card.prototype, 'count');

Não é um decorador Stage 3 genérico. O setter grava no WU, e a inscrição sincroniza o valor local.

Referência: src/adapters/lit/index.js.

lit.createSimpleElement

Constrói um custom element com template, estilos e callbacks.

createSimpleElement(config): ElementClass

  • Parâmetros: name opcional, template string ou função, styles e shadow true por padrão.
  • Retorno: Classe HTMLElement; name pode registrar o custom element.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { createSimpleElement } from 'wu-framework/adapters/lit';
const Card = createSimpleElement({ template: () => '<p>Hola</p>', styles: ':host{display:block}' });
customElements.define('simple-card', Card);

Template é inserido como HTML sem sanitização; controle seu conteúdo.

Referência: src/adapters/lit/index.js.

vanilla.registerClass

Monta uma classe de aplicação com um contêiner próprio.

registerClass(appName, AppClass, options?): Promise<boolean>

  • Parâmetros: constructorArgs, callbacks e standalone.
  • Retorno: Boolean de registro.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { registerClass } from 'wu-framework/adapters/vanilla';
class Card { constructor(container) { this.container = container; } render() { this.container.textContent = 'Hola'; } destroy() {} }
await registerClass('card', Card, { standalone: false });

Referência: src/adapters/vanilla/index.js.

vanilla.registerTemplate

Registra um template HTML com dados, estilos e scripts opcionais.

registerTemplate(appName, template, options?): Promise<boolean>

  • Parâmetros: template string; data, scripts, styles, callbacks e standalone.
  • Retorno: Boolean de registro.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { registerTemplate } from 'wu-framework/adapters/vanilla';
await registerTemplate('card', '<h2>Resumen</h2>', { styles: ['h2{margin:0}'], standalone: false });

Os scripts são código do host, e o HTML não é sanitizado. Não use conteúdo não confiável como template.

Referência: src/adapters/vanilla/index.js.

vanilla.createComponent

Cria um componente com estado local e renderização por template.

createComponent(config): VanillaComponent

  • Parâmetros: state, template(state), actions, onInit e onDestroy.
  • Retorno: {state,init,render,destroy,setState,getState}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Libera as inscrições ao desmontar o componente proprietário.
import { createComponent, register } from 'wu-framework/adapters/vanilla';
const component = createComponent({ state: { count: 1 }, template: state => `<b>${Number(state.count)}</b>` });
await register('card', component, { standalone: false });

setState mescla o estado local e renderiza o HTML novamente; não substitui wu.store.

Referência: src/adapters/vanilla/index.js.

vanilla.useWuEvents

Agrupa publicação e inscrições sem depender de um framework UI.

useWuEvents(scope?): EventsHelper

  • Parâmetros: Sem argumentos.
  • Retorno: {emit,on,once,off,cleanup}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame cleanup ao desmontar e guarde o cancelador de once se ele ficar pendente.
import { useWuEvents } from 'wu-framework/adapters/vanilla';
const events = useWuEvents();
events.on('cart:changed', console.log);
events.cleanup();

Referência: src/adapters/vanilla/index.js.

vanilla.useWuStore

Adiciona prefixos aos caminhos de leitura, gravação e escuta do store.

useWuStore(namespace?, scope?): StoreHelper

  • Parâmetros: Namespace opcional.
  • Retorno: {get,set,onChange}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Cada onChange retorna seu próprio unsubscribe; o helper não os acumula.
import { useWuStore } from 'wu-framework/adapters/vanilla';
const cart = useWuStore('cart');
cart.set('count', 1);
const stop = cart.onChange('count', console.log);
stop();

Referência: src/adapters/vanilla/index.js.

vanilla.createWuSlot

Insere um contêiner e solicita a montagem de uma app WU nele.

createWuSlot(target, props): SlotHandle

  • Parâmetros: target elemento; props name,url,fallbackText,onLoad,onError.
  • Retorno: {container,destroy}.
  • Erros: Precisa do runtime do framework e de uma instância WU acessível; controle a disponibilidade antes de executar operações.
  • Permissões: Hooks de eventos/store usam a facade da app; registro e slots usam o host. Solicite os recursos no manifest e conceda-os no shell.
  • Limpeza: Chame destroy ao remover o host.
import { createWuSlot } from 'wu-framework/adapters/vanilla';
const slot = createWuSlot(document.querySelector('#host'), { name: 'card', url: '/apps/card' });
slot.destroy();

A montagem é assíncrona internamente; o handle não é uma promessa de app montada.

Referência: src/adapters/vanilla/index.js.

react.createUseWuAI

Conecta a interface React a uma conversa de IA.

createUseWuAI(React): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Hook useWuAI(options) com messages,isStreaming,error,send,sendSync,abort,clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createUseWuAI } from 'wu-framework/adapters/react';
import React from 'react';
const useWuAI = createUseWuAI(React);

Crie o hook uma única vez fora do componente; use-o dentro do render. send usa streaming, e sendSync solicita uma resposta completa.

Referência: src/adapters/react/index.js.

preact.createUseWuAI

Conecta a interface Preact a uma conversa de IA.

createUseWuAI(hooks): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Hook useWuAI(options) com estado de mensagens e funções send/clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createUseWuAI } from 'wu-framework/adapters/preact';
import * as hooks from 'preact/hooks';
const useWuAI = createUseWuAI(hooks);

Use hooks da mesma instância Preact que renderiza o componente.

Referência: src/adapters/preact/ai.js.

vue.createUseWuAI

Conecta a interface Vue a uma conversa de IA.

createUseWuAI(Vue): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Composable com refs messages,isStreaming,error e send/clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createUseWuAI } from 'wu-framework/adapters/vue';
import * as Vue from 'vue';
const useWuAI = createUseWuAI(Vue);
const chat = useWuAI({ namespace: 'help' });

Esta variante usa refs Vue.

Referência: src/adapters/vue/ai.js.

vue.useWuAI

Conecta a interface Vue a uma conversa de IA.

useWuAI(options?): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Helper simples com messages,isStreaming,error,send,clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { useWuAI } from 'wu-framework/adapters/vue';
const chat = useWuAI({ namespace: 'help' });

Esta variante não cria refs. As propriedades copiadas inicialmente não constituem uma visualização reativa completa do estado interno; prefira createUseWuAI(Vue) em componentes.

Referência: src/adapters/vue/ai.js.

svelte.createWuAIStore

Conecta a interface Svelte a uma conversa de IA.

createWuAIStore(options?): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Store {subscribe,send,clear} cujo valor contém messages,isStreaming,error.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createWuAIStore } from 'wu-framework/adapters/svelte';
const chat = createWuAIStore({ namespace: 'help' });
const stop = chat.subscribe(console.log);
stop();

Cancelar subscribe remove esse observador local; não aborta automaticamente a conversa do provedor.

Referência: src/adapters/svelte/ai.js.

angular.createWuAIService

Conecta a interface Angular a uma conversa de IA.

createWuAIService(options?): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Serviço com getters messages,isStreaming,error e métodos send/clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createWuAIService } from 'wu-framework/adapters/angular';
const chat = createWuAIService({ namespace: 'help' });

Não é uma classe decorada Injectable nem um Observable RxJS. Integre suas mudanças ao mecanismo de detecção do host.

Referência: src/adapters/angular/ai.js.

solid.createUseWuAI

Conecta a interface Solid a uma conversa de IA.

createUseWuAI(): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: Factory de helper com accessors messages,isStreaming,error e send/clear.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { createUseWuAI } from 'wu-framework/adapters/solid';
const useWuAI = createUseWuAI();
const chat = useWuAI({ namespace: 'help' });

Os accessors leem um objeto comum: a implementação não cria signals Solid. Não presuma invalidação reativa automática.

Referência: src/adapters/solid/ai.js.

vanilla.useWuAI

Conecta a interface vanilla a uma conversa de IA.

useWuAI(options?): helper

  • Parâmetros: Runtime solicitado pela factory; o helper aceita um namespace opcional, com default como padrão.
  • Retorno: {send,clear,getMessages,getError,isStreaming}.
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { useWuAI } from 'wu-framework/adapters/vanilla';
const chat = useWuAI({ namespace: 'help' });
console.log(chat.getMessages());

clear esvazia seu histórico local e a conversa associada; atualize a UI após await send.

Referência: src/adapters/vanilla/ai.js.

lit.WuAIMixin

Conecta a interface Lit a uma conversa de IA.

WuAIMixin(Base): helper

  • Parâmetros: Classe base do elemento.
  • Retorno: Subclasse com wuAI,wuAISend(text,options),wuAISetNamespace(ns).
  • Erros: Verifique a disponibilidade de WU AI; o helper mantém um campo de erro ou retorna null se não estiver disponível.
  • Permissões: Usa ai.send do runtime global; as ações solicitadas pelo provedor mantêm a política IA configurada pelo host.
  • Limpeza: Não destrói o coordenador IA global. Aborte explicitamente o namespace do componente quando precisar cancelar solicitações pendentes.
import { WuAIMixin } from 'wu-framework/adapters/lit';
class Card extends WuAIMixin(HTMLElement) {
  connectedCallback() { this.wuAISetNamespace('card'); }
}

Não mantém mensagens reativas nem acrescenta um AbortController automaticamente.

Referência: src/adapters/lit/ai.js.

qwik.adoptQwikStyles

Copia estilos Qwik para adoptedStyleSheets do root correspondente.

adoptQwikStyles(container): () => void

  • Parâmetros: Container com estilos; precisa de CSSStyleSheet.replaceSync e adoptedStyleSheets.
  • Retorno: Função de limpeza das folhas e do observador.
  • Erros: Sem suporte a constructable stylesheets, retorna um cleanup vazio.
  • Permissões: Opera sobre os estilos do contêiner fornecido.
  • Limpeza: Chame a função retornada antes de destruir o contêiner.
import { adoptQwikStyles } from 'wu-framework/adapters/qwik';
const release = adoptQwikStyles(container);
release();

Referência: src/adapters/qwik/index.js.

qwik.ensureQwikLoader

Carrega e deduplica a inicialização do loader Qwik do documento.

ensureQwikLoader(load?): Promise<boolean>

  • Parâmetros: função load opcional; por padrão importa @builder.io/qwik/qwikloader.js. O registro Qwik passa o loader correspondente ao seu runtime.
  • Retorno: true para o primeiro carregamento, false se já estava inicializado.
  • Erros: Rejeita se o módulo loader não puder ser importado. A recuperação de uma promessa malsucedida depende da versão.
  • Permissões: O loader é código global do host.
  • Limpeza: Não oferece uma API pública para desfazer a execução do loader.
import { ensureQwikLoader } from 'wu-framework/adapters/qwik';
await ensureQwikLoader();

Referência: src/adapters/qwik/index.js.

shared.snapshot

Cria uma cópia superficial para ajudar os bindings reativos a detectar mudanças.

snapshot(value): unknown

  • Parâmetros: Array, objeto ou primitivo.
  • Retorno: Novo array, objeto superficial ou o primitivo original.
  • Erros: Propaga getters ou erros de propriedades ao copiar um objeto.
  • Permissões: Não acessa o store por conta própria.
  • Limpeza: Sem recursos persistentes.
import { snapshot } from 'wu-framework/adapters/shared';
const next = snapshot(wu.store.get('cart'));

Não é uma clonagem profunda nem uma validação de dados.

Referência: src/adapters/shared.js.

Migrar hooks e stores para 4.0

Uma emissão sem grant retorna false. Inscrever-se sem permissão lança WU_EVENT_SUBSCRIBE_DENIED; ler, observar ou escrever no store sem permissão lança WU_CAPABILITY_DENIED. O unmount libera listeners da facade. Depois, helpers de eventos avisam e não operam; chamadas de store lançam WU_APP_SCOPE_REVOKED.

// App manifest: wu.permissions. Shell registration: grants.
const permissions = ['store.read:cart.count', 'store.write:cart.count', 'events.emit:cart:changed'];
await wu.init({ apps: [{
  name: 'cart', url: '/apps/cart/',
  manifest: { entry: 'assets/cart.js', wu: { permissions } },
  grants: permissions,
}] });

Setters de React/Preact/Vue e Solid escrevem no path observado com um valor ou updater: setState(value) e setState(prev => next). A forma setState(path, value) escreve em um subpath. Sem namespace, use dois argumentos. No Svelte, set(value) substitui o valor observado e update(fn) aplica o updater conforme o contrato do store.

const useWuStore = createUseWuStore(React);
function Counter() {
  const { state, setState } = useWuStore('cart.count');
  return <button onClick={() => setState(value => (value ?? 0) + 1)}>{state ?? 0}</button>;
}

Para helpers fora do contexto de um componente, conserve a facade: Vanilla aceita useWuEvents(scope) e useWuStore(namespace, scope). resolveWu(element) encontra a facade pelo DOM em Lit, Alpine, htmx, Stimulus, Stencil e Qwik; um nó removido mantém seu scope revogado. Angular oferece WuAppScope por DI. Props e injections de compatibilidade chamados wuInstance, e helpers IA, continuam expondo o host.

Slots passam o elemento contêiner para WU: funcionam dentro de Shadow DOM e com nomes como cart.v2. Angular suporta montagem zoneless; só ativa detecção por Zone.js quando Zone.js está carregado. htmx 2 e 4 compartilham htmx.process(), mas o código de setup deve usar os eventos da sua versão. baseUrl cobre hx-action, hx-query e variantes data-hx-, e preserva URLs //.

Qwik não oferece montagem standalone: register retorna false se WU não aparecer em 3 segundos ou se Qwik não puder ser importado. Não registra um slot update. A adaptação de listeners do documento para Shadow DOM permanece ativa após desmontar.

shared.resolveWu

resolveWu(target?): WuAppFacade | WuCore | null

Aceita um nó DOM, um contexto { wu } ou uma facade. Resolve o scope do target ou do lifecycle síncrono ativo; só fora de ambos recorre ao host global. Conserve-o antes de um await se depois trabalhar fora do contexto de render. É exportado por wu-framework/adapters/shared e pelos adapters Lit, Vanilla, Alpine, htmx, Stimulus, Stencil e Qwik.

CONSTRUA O WU CONOSCO

Encontrou um bug? Tem uma ideia?

Sua experiência melhora o WU. Conte o que falhou ou ajude a manter seu desenvolvimento.

Relatar um bug Pagar um café Mais formas de participar