deno.land / x / solid@v1.5.6 / bench / sinuous.cjs
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245function getChildrenDeep(children) { return children.reduce( (res, curr) => res.concat(curr, getChildrenDeep(curr._children)), [] );}
const EMPTY_ARR = [];let tracking;let queue;
/** * Returns true if there is an active observer. * @return {boolean} */function isListening() { return !!tracking;}
/** * Creates a root and executes the passed function that can contain computations. * The executed function receives an `unsubscribe` argument which can be called to * unsubscribe all inner computations. * * @param {Function} fn * @return {*} */function root(fn) { const prevTracking = tracking; const rootUpdate = () => {}; tracking = rootUpdate; resetUpdate(rootUpdate); const result = fn(() => { _unsubscribe(rootUpdate); tracking = undefined; }); tracking = prevTracking; return result;}
/** * Sample the current value of an observable but don't create a dependency on it. * * @example * S(() => { if (foo()) bar(sample(bar) + 1); }); * * @param {Function} fn * @return {*} */function sample(fn) { const prevTracking = tracking; tracking = undefined; const value = fn(); tracking = prevTracking; return value;}
/** * Creates a transaction in which an observable can be set multiple times * but only trigger a computation once. * @param {Function} fn * @return {*} */function transaction(fn) { let prevQueue = queue; queue = []; const result = fn(); let q = queue; queue = prevQueue; q.forEach(data => { if (data._pending !== EMPTY_ARR) { const pending = data._pending; data._pending = EMPTY_ARR; data(pending); } }); return result;}
/** * Creates a new observable, returns a function which can be used to get * the observable's value by calling the function without any arguments * and set the value by passing one argument of any type. * * @param {*} value - Initial value. * @return {Function} */function observable(value) { function data(nextValue) { if (arguments.length === 0) { if (tracking && !data._observers.has(tracking)) { data._observers.add(tracking); tracking._observables.push(data); } return value; }
if (queue) { if (data._pending === EMPTY_ARR) { queue.push(data); } data._pending = nextValue; return nextValue; }
value = nextValue;
// Clear `tracking` otherwise a computed triggered by a set // in another computed is seen as a child of that other computed. const clearedUpdate = tracking; tracking = undefined;
// Update can alter data._observers, make a copy before running. data._runObservers = new Set(data._observers); data._runObservers.forEach(observer => (observer._fresh = false)); data._runObservers.forEach(observer => { if (!observer._fresh) observer(); });
tracking = clearedUpdate; return value; }
// Tiny indicator that this is an observable function. data._observers = new Set(); // The 'not set' value must be unique, so `nullish` can be set in a transaction. data._pending = EMPTY_ARR;
return [data, data];}
/** * @namespace * @borrows observable as o */
/** * Creates a new computation which runs when defined and automatically re-runs * when any of the used observable's values are set. * * @param {Function} observer * @param {*} value - Seed value. * @return {Function} Computation which can be used in other computations. */function computed(observer, value) { observer._update = update;
// if (tracking == null) { // console.warn("computations created without a root or parent will never be disposed"); // }
resetUpdate(update); update();
function update() { const prevTracking = tracking; if (tracking) { tracking._children.push(update); }
const prevChildren = update._children;
_unsubscribe(update); update._fresh = true; tracking = update; value = observer(value);
// If any children computations were removed mark them as fresh. // Check the diff of the children list between pre and post update. prevChildren.forEach(u => { if (update._children.indexOf(u) === -1) { u._fresh = true; } });
// If any children were marked as fresh remove them from the run lists. const allChildren = getChildrenDeep(update._children); allChildren.forEach(removeFreshChildren);
tracking = prevTracking; return value; }
function data() { if (update._fresh) { update._observables.forEach(o => o()); } else { value = update(); } return value; }
return data;}
function removeFreshChildren(u) { if (u._fresh) { u._observables.forEach(o => { if (o._runObservers) { o._runObservers.delete(u); } }); }}
/** * Run the given function just before the enclosing computation updates * or is disposed. * @param {Function} fn * @return {Function} */function cleanup(fn) { if (tracking) { tracking._cleanups.push(fn); } return fn;}
function _unsubscribe(update) { update._children.forEach(_unsubscribe); update._observables.forEach(o => { o._observers.delete(update); if (o._runObservers) { o._runObservers.delete(update); } }); update._cleanups.forEach(c => c()); resetUpdate(update);}
function resetUpdate(update) { // Keep track of which observables trigger updates. Needed for unsubscribe. update._observables = []; update._children = []; update._cleanups = [];}
module.exports = { createSignal: observable, createRoot: root, createComputed: computed, createMemo: computed, batch: transaction};
solid
Version Info
a year ago
