Hoppa till innehållet
Verifierad

@xuda/core

Den beroendefria reaktiva motorn som plattformen, kompilatorn och demoapparna alla monteras på.

@xuda/core är Xudas reaktiva motor (signaler, schemaläggare, nyckelad listdiff, reaktiv renderare, router) som ett beroendefritt ESM-paket. Den läser och skriver inga globaler vid import: inget func, inget SESSION_OBJ, inget window, inget document.

Det enda publika paketet i den här delen av dokumentationen

@xuda/core:s package.json har "private": false. Det är det enda paketet av de tre som tas upp i det här avsnittet (tillsammans med @xuda/compiler och @xuda/vite-plugin-xu, båda private: true) som är byggt för att användas som beroende utanför det här repot.

Det är heller inte en separat motor från den som plattformen redan levererar: paketets egna build:globals-skript (esbuild src/globals.js --bundle ... --outfile ../../runtime/js/xuda_core.globals.js) är hur runtime/js/xuda_core.globals.js, plattformens egen levererade paket med reaktiv renderare, byggs.

Den reaktiva ytan

js
import { ref, reactive, computed, effect, watch, effectScope } from '@xuda/core';

Det finns en beroendegraf, ett ägarträd, en batchbuffert och en schemaläggare under allt detta: en ref som läses inuti en effect() spåras och kör om den, på samma sätt som en signal som läses inuti en watch(). computed accepterar här en getter, eller ett { get, set }-par för en skrivbar computed.

js
const state = reactive({ count: 0 });
state.count++;             // no .get(), no .set()

const n = ref(0);
n.value++;

effectScope() svarar på "vem städar upp det här": en namngiven ägare som du kan skicka runt, nästla och stoppa i ett enda anrop, i stället för att handrulla en hög med städfunktioner.

js
const scope = effectScope();
scope.run(() => {
  effect(() => { /* ... */ });
  watch(source, callback);
  onScopeDispose(() => io.disconnect());
});
scope.stop();

En komponent som instansieras via createApp() äger redan en sådan: dess <script> körs inuti komponentens egen frikopplade scope, så en effekt som skrivs där städas automatiskt när komponenten avmonteras.

Den lågnivåprimitiva

signal(initial) (.get(), .set(), .peek(), .notify(), .subscribe()) och signalComputed är motorns egna celler under ref och computed. De exporteras och stöds fullt ut, de har inte tagits bort, eftersom renderaren och den äldre bryggan bygger på dem, och eftersom signal.notify(), som kör om prenumeranter utan värdeändring, saknar motsvarighet i ref. Applikationskod bör använda ref och computed i stället; de två namnen är dokumenterade som lagret under, inte som föråldrade i runtime (en varning på signal() skulle utlösas per radscope och per panelparameter, tusentals gånger per skärm, för kod som gör exakt rätt på det lagret).

Appens startpunkt

js
import { createApp } from '@xuda/core';
import App from './App.xu';

createApp(App).mount('#app');

App är en kompilerad .xu-modul, skapad av @xuda/compiler eller byggsteget vite-plugin-xu. createApp bygger de sju injicerade beroenden som renderaren behöver över den thunk-tabell som modulens setup() returnerar, skapar renderaren och monterar komponentträdet. Det är inte en andra renderare: den kompilerade vägen och den tolkade plattformsvägen delar render.js.

examples/hello är den konkreta, testade versionen av detta: createApp(App).mount('#app') över en kompilerad App.xu med en räknare, ett villkor och en nyckelad lista.

Renderaren, med beroendeinjektion

js
import { create_renderer } from '@xuda/core';
import { reactive } from '@xuda/core/reactivity';

create_renderer(deps) är DOM-agnostisk. Allt som hör till omgivningen kommer in via ett enda deps-objekt, och den minsta ärliga värden behöver exakt sju av dem: document (createElement / createTextNode / createComment), evaluate (en spårad, synkron uttrycksutvärderare), cast_bool (sanningsvärde för xu-render / xu-if), resolve_rows (en spårad radarrayupplösare för xu-for), row_key (stabil radidentitet), write_field (xu-bind-skrivningar) och dispatch_event (xu-on:*-hanterare). packages/core/demo bygger exakt detta över ett vanligt reactive({...})-objekt, utan SESSION_OBJ, utan datakällager och utan någon äldre brygga under.

Två tysta fällor i DOM-kontraktet, om du skriver en egen adapter

En deps.document-nod utan nodeType läses som ett jQuery-objekt i stället för en riktig DOM-nod, vilket kan nästla varje rad inuti sin föregångare utan något kastat fel. En nod utan remove() förvandlar en borttagen rad till ett tyst avvisat löfte: listan slutar uppdateras och ingenting loggas. create_adapter i demon skyddar mot båda genom att kasta ett fel när noden skapas; skicka { guard: false } för att välja bort det när du förstår varför skyddet finns.

Diagnostik och whenElement

onDiagnostic, getDiagnostics, diagnosticCount och resetDiagnostics förvandlar motorns tysta uppgivanden till en enda observerbar kanal, i stället för utspridda console.error-anrop, så att en värdadapter eller ett test kan prenumerera på dem i kod. whenElement kör en callback när en nod finns: den frågar en gång och frågar sedan igen i schemaläggarens commit-fas (exakt när DOM har lagt sig, före målning), och en väntan som fortfarande inte är uppfylld efter tjugo avslutade renderingar rapporterar sig själv med namn i stället för att tyst ge upp.

Routern

createRouter, createWebHistory, createWebHashHistory, createMemoryHistory, useRouter och useRoute levereras från samma paket. Den aktuella rutten är @xuda/core:s egen reactive, och historiken kommer från plattformen, så att använda den lägger inte till något eget beroende.

Paketexporter

Node 18 eller nyare är den deklarerade lägsta motorversionen.