eewing
70 lines
2.2 KiB
JavaScript
70 lines
2.2 KiB
JavaScript
import { untrack } from "svelte";
|
|
function runEffect(flush, effect) {
|
|
switch (flush) {
|
|
case "post":
|
|
$effect(effect);
|
|
break;
|
|
case "pre":
|
|
$effect.pre(effect);
|
|
break;
|
|
}
|
|
}
|
|
function runWatcher(sources, flush, effect, options = {}) {
|
|
const { lazy = false } = options;
|
|
// Run the effect immediately if `lazy` is `false`.
|
|
let active = !lazy;
|
|
// On the first run, if the dependencies are an array, pass an empty array
|
|
// to the previous value instead of `undefined` to allow destructuring.
|
|
//
|
|
// watch(() => [a, b], ([a, b], [prevA, prevB]) => { ... });
|
|
let previousValues = Array.isArray(sources)
|
|
? []
|
|
: undefined;
|
|
runEffect(flush, () => {
|
|
const values = Array.isArray(sources) ? sources.map((source) => source()) : sources();
|
|
if (!active) {
|
|
active = true;
|
|
previousValues = values;
|
|
return;
|
|
}
|
|
const cleanup = untrack(() => effect(values, previousValues));
|
|
previousValues = values;
|
|
return cleanup;
|
|
});
|
|
}
|
|
function runWatcherOnce(sources, flush, effect) {
|
|
const cleanupRoot = $effect.root(() => {
|
|
let stop = false;
|
|
runWatcher(sources, flush, (values, previousValues) => {
|
|
if (stop) {
|
|
cleanupRoot();
|
|
return;
|
|
}
|
|
// Since `lazy` is `true`, `previousValues` is always defined.
|
|
const cleanup = effect(values, previousValues);
|
|
stop = true;
|
|
return cleanup;
|
|
},
|
|
// Running the effect immediately just once makes no sense at all.
|
|
// That's just `onMount` with extra steps.
|
|
{ lazy: true });
|
|
});
|
|
$effect(() => {
|
|
return cleanupRoot;
|
|
});
|
|
}
|
|
export function watch(sources, effect, options) {
|
|
runWatcher(sources, "post", effect, options);
|
|
}
|
|
function watchPre(sources, effect, options) {
|
|
runWatcher(sources, "pre", effect, options);
|
|
}
|
|
watch.pre = watchPre;
|
|
export function watchOnce(source, effect) {
|
|
runWatcherOnce(source, "post", effect);
|
|
}
|
|
function watchOncePre(source, effect) {
|
|
runWatcherOnce(source, "pre", effect);
|
|
}
|
|
watchOnce.pre = watchOncePre;
|