Saltar para o conteúdo
Verificado

O guia LLM do Studio

O modelo de documentos de prog, a referência de atributos xu-* e as regras de fluxo de trabalho que um agente de IA aprende antes da sua primeira chamada a uma ferramenta.

Cada projeto do Studio, e cada tabela, ecrã, script e rota dentro dele, é um documento JSON do CouchDB chamado prog (docType: "studio"). Esta página é a mesma referência que um agente de IA recebe quando constrói um, reescrita como documentação: a forma desse documento, os atributos que comandam a sua interface, as ações que um fluxo de trabalho pode executar e os erros que surgem em construções reais.

Como um agente de IA obtém este guia

Ligue um cliente MCP ao Xuda e a primeira resposta, a chamada initialize, traz este guia como instructions da sessão, fundido de novo a partir das regras ativas da própria plataforma, para que nunca possa descrever algo que o verificador implementado já não aplique. Veja Ligar um cliente de IA por MCP.

A partir de dentro de uma sessão, dois métodos chegam diretamente ao mesmo material, por MCP ou por REST simples, e não exigem nada além de uma chave de API normal:

A ordem prescrita: leia o tópico que corresponde ao que está a construir, obtenha um exemplo correspondente, crie o prog através da fábrica (create_prog), construa dentro das suas secções de conteúdo, valide (validate_prog) e corrija tudo o que for reportado, guarde (save_prog) e volte a obter para verificar. Um guardar que devolva -409 significa que o documento mudou desde que foi lido: obtenha de novo, reaplique, tente outra vez.

O modelo de documentos de prog

O envelope

O código do servidor e da fábrica é dono destes campos; uma construção escrita só edita as secções de conteúdo abaixo deles.

json
{
  "_id": "392_cmp_f15654997737",
  "_rev": "3-...",
  "docType": "studio",
  "stat": 3,
  "app_id": "prj...",
  "properties": { "menuType": "component", "menuName": "Orders", "menuTitle": "Orders" },
  "studio_meta": { "created": 1750000000000, "createdByUid": "...", "savedByUid": "...", "parentId": "programs" }
}
  • _id segue <last 3 chars of app_id>_<3-letter type abbreviation>_<12 hex>, por exemplo 392_cmp_... para um componente, 392_tbl_... para uma tabela, 392_jvs_... para um prog javascript, 392_gtd_... / 392_std_... para get_data / set_data, 392_fld_... para uma pasta. A fábrica gera os ids, uma construção nunca inventa um.
  • stat é 3 para ativo, 4 para eliminado de forma suave (o que eliminar um prog define). A árvore do Studio só mostra stat: 3.
  • properties.menuType é um de globals, table, get_data, set_data, batch, alert, javascript, folder, route, api, component, ai_agent.
  • studio_meta.parentId coloca o nó na árvore do Studio: ou o id de outro prog (normalmente uma pasta) ou uma das raízes de tipo, programs (lógica e componentes), database (tabelas), routes, globals, ai_agents. Um parentId não reconhecido deixa o nó invisível na árvore e é um erro do verificador.

Secções de conteúdo por menuType

O documento globals

Cada projeto tem exatamente um documento global_<app_id> (menuType: "globals"). Os seus progFields são legíveis a partir de qualquer outro prog como @field_id. Dois globais de sistema vêm em todos os projetos: @SYS_GLOBAL_OBJ_LOGIN_USER_INFO para o utilizador com sessão iniciada e @SYS_GLOBAL_OBJ_REFS para os elementos registados com xu-ref. Nem o documento globals nem a raiz da árvore podem ser eliminados.

Obrigações estruturais

  • properties, properties.menuType, properties.menuName, studio_meta e studio_meta.parentId são obrigatórios em todos os documentos.
  • Uma entrada de progFields precisa de um id único, data.field_id, um data.type de virtual, table, expression ou datasource, e um props.fieldType de string, number, boolean, array ou object.
  • Os nomes de variáveis de runtime reservados, _NULL, _THIS, _FOR_KEY, _FOR_VAL, _ROWNO, _ROWID, _ROWDOC, _KEY, _VAL, nunca são redefinidos como ids de campo.
  • Ids duplicados, menuType desconhecidos e secções mal formadas são todos erros graves que o validate_prog reporta diretamente.

Expressões e atributos xu-*

Sintaxe das expressões

As expressões executam-se sobre o conjunto de dados do próprio prog. Qualquer campo, local, ligado a uma tabela, global ou um parâmetro, é referenciado com @: @search_v, @ORD_Total, @SYS_GLOBAL_OBJ_LOGIN_USER_INFO, com JavaScript simples à volta, @count_v > 0 ? 'has rows' : 'empty'. Um literal de objeto precisa de parênteses à volta, ({ ORD_Status: @status_v }). Dentro de um ciclo xu-for, o item atual é @_FOR_VAL e a sua chave ou índice @_FOR_KEY (renomeáveis com xu-for-key / xu-for-val). xu-render e outras condições devolvem diretamente o valor verdadeiro ou falso, nunca uma string "Y" / "N" nem uma comparação adicional.

xu-bind é a única exceção

Em todos os outros sítios um campo é referenciado com @. O xu-bind recebe o id do campo simples: xu-bind="search_v", nunca xu-bind="@search_v".

Os atributos xu

Famílias de prefixos

Famílias de atributos que recebem um sufixo. Os valores de xu-on são sempre arrays de objetos de tratamento; os valores de xu-exp são sempre strings de expressão.

json
"xu-on:click": [{
  "handler": "custom",
  "props": {},
  "workflow": [
    { "id": "1", "data": { "action": "update", "name": { "value": "@saving_v: true" }, "enabled": true }, "props": {} },
    { "id": "2", "data": { "action": "set_data", "name": { "prog": "392_std_...", "properties": {}, "parameters": {} }, "enabled": true }, "props": { "condition": "@form_valid_v" } }
  ]
}]

O valor de um atributo xu-on:* é sempre um array de objetos de tratamento, e cada workflow é um array de passos de ação (a referência completa das ações está abaixo, em Programas de lógica e fluxos de trabalho). O props.condition de um passo condiciona-o; props.async: true dispara-o sem esperar.

Semântica crítica

  • xu-exp:class substitui o atributo class estático em vez de lhe acrescentar. Num elemento que tenha ambos, o estático é ignorado, por isso as classes de layout pertencem também dentro da expressão: xu-exp:class="'card p-4 ' + (@active_v ? 'ring' : '')".
  • xu-script recebe uma expressão function (el) { ... } simples, avaliada com eval e chamada com o elemento do DOM quando o nó se torna visível. Proteja-se contra novas execuções (if (el.__bound) return; el.__bound = true;) e limite todas as consultas a el, nunca a document.
  • xu-style tem âmbito automático: cada seletor recebe como prefixo o [xu-ui-id] do nó, por isso os seletores simples de elementos e classes ficam locais e nunca vazam.
  • Nem os valores de xu-script nem os de xu-style podem conter um carácter de aspas (' ou "): o canvas do designer serializa os atributos sem escape e uma só aspa corrompe o componente. A secção Programas JavaScript abaixo trata de técnicas sem aspas.
  • O texto estático pertence à propriedade content de um elemento. xu-exp:xu-content serve apenas para texto dinâmico.

Tags

Tags de escrita para além do HTML simples: xu-template, xu-single-view, xu-multi-view, xu-panel, xu-teleport, xu-slot.

  • xu-single-view delimita um único registo (uma raiz de formulário, utilizável também aninhada).
  • xu-multi-view repete os seus filhos uma vez por linha dos dados ligados.
  • xu-panel incorpora outro prog (atributo program mais entradas xu-exp:<param>). Para além das expressões de parâmetros, só pertencem a ele atributos HTML padrão (class, id, style, title, hidden, slot, name, role, tabindex).
  • xu-teleport renderiza os seus filhos noutro destino do DOM (to ou xu-exp:to).
  • Um nome de tag com maiúscula inicial (Button, Card) é um componente compilado, não um elemento HTML, veja Incorporar abaixo.

Componentes

Um componente (menuType: "component") é uma unidade de interface: uma árvore de elementos (progUi) ligada ao estado local (progFields), a dados opcionais (progDataSource), a lógica de ciclo de vida (progEvents) e a uma interface de entrada/saída (properties.progParams).

Propriedades

json
{
  "menuType": "component", "menuName": "OrderList",
  "renderType": "form",
  "uiFramework": "@xuda.io/xuda-framework-plugin-tailwind",
  "rwMode": "R",
  "progParams": [{ "id": 1, "data": { "dir": "in", "parameter": "order_id_in", "type": "string" }, "props": {} }]
}
  • renderType é form para um único registo (elemento raiz xu-single-view) ou grid / list para um repetido por cada linha de dados (elemento raiz xu-multi-view).
  • rwMode é R para leitura ou U para atualização; allowCreate indica se pode ser inserida uma nova linha quando nenhuma corresponde.
  • Convenção de nomes de progParams: os parâmetros terminam em _in / _out, os campos virtuais locais do componente terminam em _v.
  • uiFramework reflete o que os componentes já existentes do projeto usam. Um projeto existente que o omita deve continuar a omiti-lo: definir um plugin de framework que o drive do projeto não serve de facto deixa a pré-visualização em direto parada num ecrã em branco.

A árvore de elementos (progUi)

json
{
  "id": "root", "type": "element", "tagName": "xu-single-view", "attributes": {},
  "children": [
    { "id": "ui-...", "type": "element", "tagName": "div",
      "attributes": { "class": "card", "xu-style": ".card { padding: 16px; border-radius: 12px; }" },
      "children": [
        { "id": "ui-...", "type": "element", "tagName": "h2", "content": "Orders", "attributes": {}, "children": [] },
        { "id": "ui-...", "type": "element", "tagName": "input", "children": [],
          "attributes": { "type": "text", "placeholder": "Search", "xu-bind": "search_v" } }
      ] }
  ]
}

O nó root da fábrica mantém-se; uma construção trabalha dentro dos seus children. Cada nó precisa de um id único (os novos nós usam ui-<uuid>), type: "element" e um tagName, sem tipos de nó comment nem text, o texto estático vive em content. Cada nó precisa de attributes: {} e children: [] mesmo quando vazios: o serializador do canvas do designer desreferencia ambos em cada nó e uma omissão estraga a pré-visualização do próprio componente.

Incorporar: xu-panel ou um componente compilado

Ambos se montam de forma transparente, sem elemento invólucro, e ambos são decididos por um só sinal: se tagName começa por uma letra maiúscula.

  • xu-panel, tagName em minúsculas mais um atributo program, incorpora outro prog, um filho ligado a uma base de dados ou com estado, com os seus próprios campos e eventos. program é o id do filho (ou xu-exp:prog para um dinâmico), os valores chegam aos seus parâmetros _in através de xu-exp:<param>.
  • Uma tag com maiúscula inicial mais um atributo library monta um componente compilado, uma primitiva de design system ou uma peça que a própria aplicação compilou. Cada atributo simples torna-se uma prop (props.<name>), nunca um atributo do DOM, uma vez que o componente não renderiza nenhum elemento próprio. Um nó de componente não tem parâmetros de saída: ao contrário do xu-panel, nada escreve um valor de volta nos seus campos.
Só a capitalização decide

Um <Buton> com erro de digitação continua a ser reclamado como tag de componente, nunca recorre a um elemento HTML desconhecido e lança um erro ao montar, indicando a tag, a biblioteca e todas as origens tentadas. O validate_prog não verifica tags de componentes nem valores de library hoje, a pré-visualização em direto é a única verificação.

progFields

json
[
  { "id": "<uuid>", "data": { "type": "virtual", "field_id": "search_v" }, "props": { "fieldType": "string" }, "workflow": [] },
  { "id": "<uuid>", "data": { "type": "table", "field_id": "ORD_Total" }, "props": { "fieldType": "number" }, "workflow": [] }
]

data.type é virtual para estado local, table para uma coluna do datasource ligado, ou expression / datasource. O workflow de um campo executa-se quando ele muda. Uma predefinição define props.fieldValue; um campo calculado define props.fieldComputed: true mais propExpressions.fieldValue.

progDataSource

Um único registo por chave (formulário): dataSourceFilterModelType: "index" com um dataSourceIndexId que existe nos próprios tableIndexes da tabela. Uma lista filtrada (grid ou list): dataSourceFilterModelType: "query" com filterModelMongoFx, uma string de expressão ao estilo Mongo. dataSourceType é table, array, json, csv, none, ou vazio para um componente puramente de apresentação sem nenhuma fonte de dados.

progEvents e os três hooks de ciclo de vida

Tipos de evento: on_load, on_exit, before_record, after_record, record_not_found, locate_not_found, screen_ready, on_refresh, on_unload, client_interval, user_defined. Os eventos user_defined são disparados de qualquer sítio com a ação raise_event; screen_ready é o hook de montagem habitual.

Os três hooks incorporados de um componente repartem o trabalho, e usar o errado é uma fonte comum de erros:

screen_ready

Dispara uma vez por instância. Crie aqui o DOM e os widgets.

on_refresh

Dispara após cada carregamento, incluindo o primeiro, logo a seguir a screen_ready. Entregue os novos dados a widgets que já existem. Pôr o trabalho de atualização em screen_ready faz voltar a executar o código de criação sobre DOM que ainda existe e empilha um segundo widget.

on_unload

Dispara quando a instância é desmontada. Destrua o que o prog criou: widgets, temporizadores, ouvintes de document / window, observadores. O motor só consegue libertar o que criou: um ouvinte ligado a document sobrevive ao painel de outra forma.

Padrões

  • Estados de carregamento e de vazio: ponha xu-ref="myref" no elemento ligado a dados e depois condicione os elementos de esqueleto ou de vazio com xu-render sobre (@SYS_GLOBAL_OBJ_REFS).myref, o seu conjunto de dados fica associado quando os dados chegam.
  • Modais: construa a caixa de diálogo como um componente próprio e abra-a com a ação call_modal.
  • Guardar ou eliminar uma linha ligada: invoke_action com act_save / act_delete, ou um prog set_data dedicado para qualquer coisa para além da linha atual.

Programas de lógica e fluxos de trabalho

Os tipos de prog de lógica partilham a maquinaria de dados de um componente (progDataSource, progFields, progEvents, properties.progParams) sem qualquer interface:

Parâmetros

json
"progParams": [
  { "id": 1, "data": { "dir": "in",  "parameter": "order_id_in", "type": "string" }, "props": {} },
  { "id": 2, "data": { "dir": "out", "parameter": "total_out",   "type": "number" }, "props": {} }
]

Quem chama passa valores através de name.parameters da ação, { "order_id_in": { "value": "", "fx": "@selected_id_v" } }, value para um valor estático, fx para uma expressão. O verificador confirma que o programa de destino existe e que o seu menuType corresponde à ação.

Ações de fluxo de trabalho

Um fluxo de trabalho é um array de passos, { "id": "...", "data": { "action": "...", "name": { ... }, "enabled": true }, "props": {} }, executados por ordem. props.condition condiciona um passo, props.async: true dispara-o sem esperar. Os fluxos de trabalho aparecem em tratadores xu-on:*, progEvents[].workflow e no próprio workflow de um campo.

O invoke_action aceita act_next, act_prev, act_first, act_last, act_reload, act_refresh, act_print, act_save, act_delete (apenas em contexto de componente).

Ações obsoletas que o verificador rejeita

alter_ui_element, create_ui_element, info_ui_element, remove_ui_element, empty_ui_element, cache_ui_element, load_ui_element. Conduza a interface através de campos e de xu-exp / xu-render em vez de uma ação imperativa sobre elementos.

call_ai_agent e call_triage_agent não são ações reais

O próprio seletor de ações do Studio oferece Call AI Agent e Call Triage Agent a seguir às ações acima. Nenhuma está nesta tabela porque nenhuma é uma ação: o validate_prog não tem nenhum caso para elas e reporta invalid trigger type, e o motor de fluxos de trabalho do runtime também não tem tratador para elas, por isso um passo guardado nunca se executa, mesmo que o erro seja ignorado. Para fazer um prog alcançar um agente publicado, adicione uma ferramenta AI Agent à lista de ferramentas de outro agente (o agentConfig.agent_tools de um documento menuType: "ai_agent"), não um passo de fluxo de trabalho num componente, get_data ou qualquer outro tipo de prog.

O name.value de update atribui campos com pares @field: expression separados por ponto e vírgula, ou com um objeto JSON5, "@saving_v: true; @status_v: 'sent'". Chamar outro programa indica-o em name.prog, fazendo corresponder a ação ao tipo do próprio programa (get_data precisa de um prog get_data, call_native_javascript de um prog javascript, e assim por diante).

O call_library chama um método de plugin instalado: name.plugin_name tem de estar comprado e instalado na aplicação ou o verificador rejeita o passo, name.library_method um dos métodos que o plugin exporta, name.library_props os seus campos declarados. Dois nomes de props são uma convenção entre plugins e não específicos de nenhum: event_name_for_successful_callback dispara esse evento com a resposta do método, field_id_to_return_result escreve a resposta diretamente nesse campo, nenhum é obrigatório.

Tipos de progEvents

on_load, on_exit, before_record, after_record, record_not_found, locate_not_found, screen_ready, on_refresh, on_unload, client_interval, user_defined. screen_ready é o hook de inicialização habitual; before_record / after_record / record_not_found / locate_not_found são ciclo de vida de dados, sobretudo para set_data e batch; client_interval é um temporizador repetitivo; user_defined dispara a partir da ação raise_event.

Tabelas

Um prog de tabela (menuType: "table") define uma tabela de base de dados: as suas colunas (tableFields), os seus índices (tableIndexes) e o plugin de base de dados que a armazena (properties.databaseSocket). Pai na árvore: database, ou uma pasta dentro dela.

json
{
  "properties": { "menuType": "table", "menuName": "ORD - Orders", "databaseSocket": "@xuda.io/xuda-dbs-plugin-xuda" },
  "tableFields": [
    { "id": "<uuid>", "data": { "field_id": "ORD_Id" }, "props": { "fieldType": "string", "mandatory": true } }
  ],
  "tableIndexes": [
    { "id": "<uuid>", "data": { "name": "index_1", "unique": true, "keys": ["ORD_Id"] }, "props": {} }
  ]
}
  • databaseSocket tem de indicar um plugin de base de dados instalado no projeto, @xuda.io/xuda-dbs-plugin-xuda é a predefinição da plataforma; uma tabela existente no mesmo projeto é a referência para saber que socket reutilizar.
  • É exigido pelo menos um campo e pelo menos um índice.
  • field_id começa por uma letra, seguida de letras, dígitos, sublinhado, hífen, dois pontos ou ponto, e é único dentro da tabela.
  • fieldType é string, number, boolean, array, object ou date; mandatory: true torna-o obrigatório ao guardar.
  • Cada índice precisa de um name e de keys não vazios, e cada chave tem de ser um field_id existente.

Convenção: prefixe as colunas com um código de tabela de três letras, uma tabela chamada "ORD - Orders" recebe ORD_Id, ORD_Total, ORD_Status. Dê a cada tabela um campo <TBL>_Id único com um índice único sobre ele, a ligação de um componente a um só registo precisa dele.

Uma tabela é usada de três formas: o progDataSource.dataSourceTableId de um componente ou consulta, um prog get_data / set_data / batch para acesso ao nível da linha a partir de fluxos de trabalho, ou xu.dbs_create / dbs_read / dbs_update / dbs_delete a partir de um script, tratado a seguir.

Programas JavaScript

Um prog javascript (menuType: "javascript") contém código-fonte JS real em scriptData.value, compilado ao guardar. O save_prog dispara essa compilação e devolve o resultado como data.compile, { ok: true, dependencies } ou { ok: false, error }. Uma compilação falhada guarda na mesma o documento, por isso uma construção lê compile.ok e corrige antes de avançar.

O contrato de execução

A fonte é escrita como um corpo assíncrono simples, sem export, sem invólucro. Em runtime executa-se como:

js
async function (params, xu, SESSION_ID, SESSION_OBJ, jobNoP, $container, func, glb, APP_OBJ, evt) {
  /* source */
}

params são as entradas já avaliadas de quem chama; xu é a API de runtime abaixo; um valor de retorno é opcional, a forma idiomática de devolver resultados é xu.set_field_value nos campos do componente que chama. Aqui as aspas são aceites, ao contrário do valor de um atributo xu-script.

A API de runtime xu

js
const raw = await xu.get_field_value(`rows_json_v`);
const rows = typeof raw === `string` ? JSON.parse(raw || `[]`) : raw || [];
for (const row of rows) {
  await xu.dbs_create(`392_tbl_...`, { CNT_Name: row.name || ``, CNT_Email: row.email || `` });
}
// dbs_read resolves to an ARRAY of { id, value } rows: the row id on .id, table fields under .value.
const all = await xu.dbs_read(`392_tbl_...`, {}, [], null, 999);
await xu.set_field_value(`status_v`, `Saved ` + rows.length + ` rows`);

Os métodos dbs_* recebem o _id do próprio prog da tabela, nunca um nome. Os seletores são objetos ao estilo Mongo sobre os ids de campos, {} devolve tudo (limite predefinido 999). A projeção fields é opcional: [] devolve todos os campos e uma lista de ids de campos devolve só esses.

Passar dados: campos, não parâmetros

O call_native_javascript não avalia os invólucros de parâmetros {value, fx}, name.parameters chega em bruto ao script. O contrato fiável: o componente põe primeiro a carga num campo (um passo update ou uma entrada xu-bind), o fluxo de trabalho chama o prog com parameters: {} vazio e o script lê-a com xu.get_field_value e reporta com xu.set_field_value. Ao chamar a partir de outro script, xu.call_javascript(prog_id, {...}) já passa os parâmetros diretamente.

Particularidades da pré-visualização em direto

  • As escritas de dados chegam à base de dados real, mas o xu.dbs_read lê um armazenamento local de rascunho que pode não conter linhas novas do servidor: uma leitura logo a seguir a uma escrita pode vir vazia na pré-visualização mesmo que a escrita tenha chegado (visível no separador Dados da tabela no Studio). As aplicações implementadas leem e escrevem o mesmo armazenamento.
  • Os scripts compilados ficam muito em cache nas pré-visualizações de desenvolvimento: uma pré-visualização em execução pode continuar a executar o script anterior mesmo depois de recarregamentos, após um guardar recompilá-lo. Um refrescamento forçado do navegador limpa-o.
  • O xu.alert com apresentação modal, toast ou browser pode surgir como um alert() nativo e bloqueante na pré-visualização. O xu.set_field_value para um campo de estado é a forma mais segura de reportar.

prog javascript vs atributo xu-script

Técnicas sem aspas para xu-script / xu-style

O canvas do designer serializa os valores de atributos sem escape, por isso uma só aspa corrompe a marcação do componente. Os template literals evitam por completo as aspas de strings (el.textContent = `Ready`); o carácter literal ", por exemplo ao construir CSV, vem de String.fromCharCode(34); os seletores de atributos CSS são válidos sem aspas (el.querySelector(`[data-role=import-btn]`)); e uma proteção contra nova execução, if (el.__bound) return; el.__bound = true;, impede um script de se ligar duas vezes ao voltar a renderizar.

Armadilhas

Cada entrada abaixo estragou uma construção real em algum momento. O validate_prog apanha a maioria delas, execute-o antes de cada guardar.

Mecânica da API

  • Toda a resposta é { code, data }, code < 0 é um erro.
  • O create_prog devolve o novo documento em data.prog, guardar a resposta inteira em vez disso persiste um documento mal formado com properties enterrado em prog.
  • O save_prog substitui o documento inteiro. Parta do documento atual, nunca de um esqueleto montado à mão; um -409 significa que mudou desde a última leitura: obtenha de novo, reaplique, tente outra vez.
  • Por MCP, prog_json e properties_json são passados como strings: a camada de esquema da ferramenta retira as chaves desconhecidas de um parâmetro de objeto e pode descartar secções inteiras em silêncio.
  • O delete_prog é uma eliminação suave, define stat: 4. O nó global_<app_id> não pode ser eliminado.

Conteúdo do documento

  • Nenhum ' nem " dentro de valores de xu-script ou xu-style.
  • As chaves com prefixo $ ($folded, $childrenClass, $nodeBackClass), mais path, code, editCode, são estado de vista do designer e nunca pertencem a um nó de progUi guardado.
  • Nenhum tipo de nó comment nem text, apenas elementos, texto estático em content.
  • Cada nó de elemento precisa de attributes: {} e children: [] mesmo quando vazios.
  • xu-exp:class substitui o class estático, todas as classes necessárias pertencem dentro da expressão.
  • xu-bind é um id de campo simples, sem @, em todos os outros sítios os campos usam @.
  • Só os atributos xu-* documentados fazem alguma coisa, um inventado é ignorado em silêncio e o validate_prog avisa.
  • A raiz da árvore de um prog ai_agent é ai_agents, guarde-o com studio_meta.parentId: "ai_agents" (ou um id de pasta dentro dela) se o verificador assinalar parentId.

Runtime e renderização

  • Um tagName com maiúscula inicial é sempre reclamado como componente, mesmo um erro de digitação, e lança um erro ao montar indicando a tag, a library e todas as origens tentadas, não há um "não renderiza" silencioso como acontece com um xu-panel sem programa selecionado.
  • O validate_prog não verifica tags de componentes nem valores de library, só a pré-visualização em direto apanha um com erro ortográfico.
  • Nenhum CSS utilitário (Tailwind ou outro) em runtime a menos que o plugin uiFramework do projeto o forneça realmente, classes como p-4 não fazem nada em silêncio caso contrário. O estilo autónomo é xu-style, com âmbito automático por [xu-ui-id].
  • O xu-script executa-se uma vez por visibilidade do elemento e pode voltar a disparar ao renderizar de novo, proteja com el.__bound e limite as consultas a el.

Dados e scripts

  • Os parâmetros de call_native_javascript não são avaliados, passe os dados através de campos (veja Passar dados, acima).
  • As linhas de dbs_read são {id, value}, os campos vivem em .value, o id da linha em .id. Não passe uma projeção fields, estraga a leitura no servidor.
  • Dentro de xu-for, ponha o iterador entre parênteses, (@_FOR_VAL).CNT_Name é avaliado, @_FOR_VAL.CNT_Name falha em silêncio e renderiza em vez disso o texto-fonte substituído.
  • As escritas da pré-visualização chegam à base de dados real; as leituras da pré-visualização vêm de um armazenamento local de rascunho que pode parecer vazio logo a seguir a uma escrita.
  • Prefira um campo de estado à apresentação modal ou toast de xu.alert nas pré-visualizações, pode ser renderizada como um alert() nativo e bloqueante.

Verificar o seu trabalho

Volte a obter com get_prog depois de guardar e compare com o esperado. Para trabalho de interface, abra o componente no Studio e prima o botão de reprodução da pré-visualização, ou o URL de pré-visualização em direto do projeto quando existir. Para um prog javascript, verifique data.compile.ok em cada guardar. Corrija todos os erros do validate_prog; trate os seus avisos, aspas, chaves $, atributos desconhecidos, como itens a corrigir já e não como ruído.