Framework minimalist JavaScript pentru programare reactivă cu scheduler prioritar, batching și gestionarea ciclurilor de dependență pentru performanță optimă.
// Framework minimalist pentru programare reactivă cu scheduler de prioritate, batching și gestionarea ciclurilor de dependență
// --- Gestionarea globală a stării de execuție ---
const currentEffectStack = [];
// --- Scheduler cu prioritate și batching ---
class Scheduler {
constructor() {
// Hartă a efectelor în coadă cu prioritatea lor
this.queue = new Map();
// Flag pentru a indica dacă batching-ul este în curs
this.isBatching = false;
}
// Adaugă un efect în coadă cu o prioritate
schedule(effect, priority = 0) {
// Dacă efectul este deja programat, actualizează prioritatea dacă este mai mare
if (this.queue.has(effect)) {
const oldPriority = this.queue.get(effect);
if (priority > oldPriority) {
this.queue.set(effect, priority);
}
} else {
this.queue.set(effect, priority);
}
// Dacă nu suntem în batch, execută imediat flush-ul
if (!this.isBatching) {
this.flush();
}
}
// Execută toate efectele programate în ordinea priorității
flush() {
if (this.queue.size === 0) return;
this.isBatching = true;
// Sortează efectele după prioritate descrescătoare
const effectsToRun = Array.from(this.queue.entries())
.sort((a, b) => b[1] - a[1])
.map(entry => entry[0]);
this.queue.clear();
for (const effect of effectsToRun) {
effect.run();
}
this.isBatching = false;
}
// Permite executarea unei funcții în modul batch
batch(fn) {
this.isBatching = true;
try {
fn();
} finally {
this.isBatching = false;
this.flush();
}
}
}
const scheduler = new Scheduler();
// --- Clasa Signal ---
class Signal {
constructor(value) {
// Valoare internă
this._value = value;
// Set de efecte care depind de acest semnal
this.subscribers = new Set();
}
// Getter pentru valoare, înregistrează dependența dacă suntem într-un efect
get value() {
const currentEffect = currentEffectStack[currentEffectStack.length - 1];
if (currentEffect) {
this.subscribers.add(currentEffect);
currentEffect.dependencies.add(this);
}
return this._value;
}
// Setter pentru valoare, notifică efectele doar dacă se schimbă
set value(newValue) {
if (Object.is(this._value, newValue)) return;
this._value = newValue;
// Notifică efectele
for (const effect of this.subscribers) {
// Programează cu prioritate 1 pentru actualizări
scheduler.schedule(effect, 1);
}
}
// Elimină un efect din subscriberi (folosit pentru curățare)
unsubscribe(effect) {
this.subscribers.delete(effect);
}
}
// --- Clasa Effect ---
class Effect {
constructor(fn) {
this.fn = fn;
// Set de semnale de care depinde
this.dependencies = new Set();
// Flag pentru a evita recursiile
this.isRunning = false;
// Execută funcția prima dată
this.run();
}
// Execută efectul cu gestionarea dependențelor și ciclului
run() {
if (this.isRunning) {
// Ciclu de dependență detectat
throw new Error('Ciclu de dependență detectat în Effect');
}
this.cleanup();
try {
this.isRunning = true;
currentEffectStack.push(this);
this.fn();
} finally {
currentEffectStack.pop();
this.isRunning = false;
}
}
// Elimină dependențele anterioare
cleanup() {
for (const dep of this.dependencies) {
dep.unsubscribe(this);
}
this.dependencies.clear();
}
}
// --- API public ---
function signal(initialValue) {
return new Signal(initialValue);
}
function effect(fn) {
return new Effect(fn);
}
function batch(fn) {
scheduler.batch(fn);
}
// --- Exemplu complet de utilizare ---
/*
const a = signal(1);
const b = signal(2);
const c = signal(3);
const sum = signal(0);
// Efect care actualizează sum când a,b,c se schimbă
const eff = effect(() => {
sum.value = a.value + b.value + c.value;
console.log('Sumă actualizată:', sum.value);
});
// Batch de actualizări
batch(() => {
a.value = 10;
b.value = 20;
c.value = 30;
});
// Output așteptat:
// Sumă actualizată: 6 (inițial)
// Sumă actualizată: 60 (după batch)
*/
export { signal, effect, batch };Semnale (Signal): unități de stare reactivă care notifică observatorii la schimbare.
Efecte (Effect): funcții reactive care se reexecută automat când semnalele de care depind se schimbă.
Scheduler de prioritate: gestionează o coadă de actualizări cu prioritate pentru a optimiza ordinea de execuție a efectelor.
Batching: grupează mai multe actualizări pentru a executa efectele o singură dată după toate modificările.
Gestionarea ciclurilor de dependență: detectează și previne ciclurile infinite între semnale și efecte.
Configurare software: fără dependențe externe, cod vanilla JavaScript ES6+, compatibil cu Node.js și browsere moderne.
Wiring/pini Arduino: nu se aplică, framework software pur fără componente hardware.