INIT

node_modules/runed/dist/utilities/watch/watch.svelte.js

@@ -0,0 +1,69 @@
+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;