filepond 5.0.0-beta.2 → 5.0.0-beta.21

package/esm/svelte/svelte/src/internal/client/reactivity/batch.js

@@ -1,16 +1,21 @@
-import { CLEAN as d, INERT as v, BOUNDARY_EFFECT as B, EFFECT as L, BLOCK_EFFECT as T, DIRTY as E, DERIVED as g, WAS_MARKED as D, ERROR_VALUE as V, BRANCH_EFFECT as Y, ROOT_EFFECT as q, MAYBE_DIRTY as z, DESTROYED as b, ASYNC as H, HEAD_EFFECT as K } from "../constants.js";
-import { deferred as U } from "../../shared/utils.js";
-import { is_dirty as M, update_effect as y, set_signal_status as m, set_is_updating_effect as A, active_effect as j, is_updating_effect as W } from "../runtime.js";
-import { effect_update_depth_exceeded as G } from "../errors.js";
-import { queue_micro_task as J } from "../dom/task.js";
-import S from "../../../../../esm-env/false.js";
-import { invoke_error_boundary as P } from "../error-handling.js";
-import { old_values as N } from "./sources.js";
-import { unlink_effect as Q } from "./effects.js";
+import { DIRTY as v, MAYBE_DIRTY as T, CLEAN as h, INERT as w, EFFECT as D, BLOCK_EFFECT as x, ERROR_VALUE as j, RENDER_EFFECT as z, MANAGED_EFFECT as G, REACTION_RAN as H, ROOT_EFFECT as I, BRANCH_EFFECT as F, DERIVED as N, DESTROYED as g, ASYNC as K } from "../constants.js";
+import { deferred as Z, includes as J } from "../../shared/utils.js";
+import { is_dirty as Y, update_effect as y, active_effect as P, active_reaction as S } from "../runtime.js";
+import { effect_update_depth_exceeded as Q } from "../errors.js";
+import { queue_micro_task as k } from "../dom/task.js";
+import { invoke_error_boundary as W } from "../error-handling.js";
+import { old_values as L } from "./sources.js";
+import { unlink_effect as X } from "./effects.js";
+import { defer_effect as $ } from "./utils.js";
+import { UNINITIALIZED as tt } from "../../../constants.js";
+import { set_signal_status as d } from "./status.js";
 const p = /* @__PURE__ */ new Set();
-let l = null, _ = null, u = [], C = null, F = !1;
-class k {
-  committed = !1;
+let u = null, m = null, C = null, b = !1, E = null, R = null;
+var M = 0;
+let et = 1;
+class A {
+  // for debugging. TODO remove once async is stable
+  id = et++;
   /**
    * The current values of any sources that are updated in this batch
    * They keys of this map are identical to `this.#previous`
@@ -26,18 +31,18 @@ class k {
   /**
    * When the batch is committed (and the DOM is updated), we need to remove old branches
    * and append new ones by calling the functions added inside (if/each/key/etc) blocks
-   * @type {Set<() => void>}
+   * @type {Set<(batch: Batch) => void>}
    */
   #s = /* @__PURE__ */ new Set();
   /**
    * If a fork is discarded, we need to destroy any effects that are no longer needed
    * @type {Set<(batch: Batch) => void>}
    */
-  #i = /* @__PURE__ */ new Set();
+  #n = /* @__PURE__ */ new Set();
   /**
    * The number of async effects that are currently in flight
    */
-  #t = 0;
+  #l = 0;
   /**
    * The number of async effects that are currently in flight, _not_ inside a pending boundary
    */
@@ -47,323 +52,355 @@ class k {
    * TODO replace with Promise.withResolvers once supported widely enough
    * @type {{ promise: Promise<void>, resolve: (value?: any) => void, reject: (reason: unknown) => void } | null}
    */
-  #l = null;
+  #u = null;
   /**
-   * Deferred effects (which run after async work has completed) that are DIRTY
+   * The root effects that need to be flushed
    * @type {Effect[]}
    */
-  #r = [];
+  #t = [];
   /**
-   * Deferred effects that are MAYBE_DIRTY
-   * @type {Effect[]}
+   * Deferred effects (which run after async work has completed) that are DIRTY
+   * @type {Set<Effect>}
    */
-  #n = [];
+  #r = /* @__PURE__ */ new Set();
   /**
-   * A set of branches that still exist, but will be destroyed when this batch
-   * is committed — we skip over these during `process`
+   * Deferred effects that are MAYBE_DIRTY
    * @type {Set<Effect>}
    */
-  skipped_effects = /* @__PURE__ */ new Set();
+  #e = /* @__PURE__ */ new Set();
+  /**
+   * A map of branches that still exist, but will be destroyed when this batch
+   * is committed — we skip over these during `process`.
+   * The value contains child effects that were dirty/maybe_dirty before being reset,
+   * so they can be rescheduled if the branch survives.
+   * @type {Map<Effect, { d: Effect[], m: Effect[] }>}
+   */
+  #i = /* @__PURE__ */ new Map();
   is_fork = !1;
-  is_deferred() {
+  #o = !1;
+  #a() {
     return this.is_fork || this.#f > 0;
   }
   /**
-   *
-   * @param {Effect[]} root_effects
+   * Add an effect to the #skipped_branches map and reset its children
+   * @param {Effect} effect
    */
-  process(e) {
-    u = [], this.apply();
-    var t = {
-      parent: null,
-      effect: null,
-      effects: [],
-      render_effects: [],
-      block_effects: []
-    };
-    for (const f of e)
-      this.#o(f, t);
-    this.is_fork || this.#u(), this.is_deferred() ? (this.#e(t.effects), this.#e(t.render_effects), this.#e(t.block_effects)) : (l = null, O(t.render_effects), O(t.effects), this.#l?.resolve()), _ = null;
+  skip_effect(t) {
+    this.#i.has(t) || this.#i.set(t, { d: [], m: [] });
+  }
+  /**
+   * Remove an effect from the #skipped_branches map and reschedule
+   * any tracked dirty/maybe_dirty child effects
+   * @param {Effect} effect
+   */
+  unskip_effect(t) {
+    var e = this.#i.get(t);
+    if (e) {
+      this.#i.delete(t);
+      for (var i of e.d)
+        d(i, v), this.schedule(i);
+      for (i of e.m)
+        d(i, T), this.schedule(i);
+    }
+  }
+  #h() {
+    if (M++ > 1e3 && (p.delete(this), it()), !this.#a()) {
+      for (const n of this.#r)
+        this.#e.delete(n), d(n, v), this.schedule(n);
+      for (const n of this.#e)
+        d(n, T), this.schedule(n);
+    }
+    const t = this.#t;
+    this.#t = [], this.apply();
+    var e = E = [], i = [], r = R = [];
+    for (const n of t)
+      try {
+        this.#c(n, e, i);
+      } catch (l) {
+        throw V(n), l;
+      }
+    if (u = null, r.length > 0) {
+      var f = A.ensure();
+      for (const n of r)
+        f.schedule(n);
+    }
+    if (E = null, R = null, this.#a()) {
+      this.#d(i), this.#d(e);
+      for (const [n, l] of this.#i)
+        U(n, l);
+    } else {
+      this.#l === 0 && p.delete(this), this.#r.clear(), this.#e.clear();
+      for (const n of this.#s) n(this);
+      this.#s.clear(), O(i), O(e), this.#u?.resolve();
+    }
+    var o = (
+      /** @type {Batch | null} */
+      /** @type {unknown} */
+      u
+    );
+    if (this.#t.length > 0) {
+      const n = o ??= this;
+      n.#t.push(...this.#t.filter((l) => !n.#t.includes(l)));
+    }
+    o !== null && (p.add(o), o.#h()), p.has(this) || this.#p();
   }
   /**
    * Traverse the effect tree, executing effects or stashing
    * them for later execution as appropriate
    * @param {Effect} root
-   * @param {EffectTarget} target
+   * @param {Effect[]} effects
+   * @param {Effect[]} render_effects
    */
-  #o(e, t) {
-    e.f ^= d;
-    for (var f = e.first; f !== null; ) {
-      var s = f.f, i = (s & (Y | q)) !== 0, o = i && (s & d) !== 0, a = o || (s & v) !== 0 || this.skipped_effects.has(f);
-      if ((f.f & B) !== 0 && f.b?.is_pending() && (t = {
-        parent: t,
-        effect: f,
-        effects: [],
-        render_effects: [],
-        block_effects: []
-      }), !a && f.fn !== null) {
-        i ? f.f ^= d : (s & L) !== 0 ? t.effects.push(f) : M(f) && ((f.f & T) !== 0 && t.block_effects.push(f), y(f));
-        var n = f.first;
-        if (n !== null) {
-          f = n;
+  #c(t, e, i) {
+    t.f ^= h;
+    for (var r = t.first; r !== null; ) {
+      var f = r.f, o = (f & (F | I)) !== 0, n = o && (f & h) !== 0, l = n || (f & w) !== 0 || this.#i.has(r);
+      if (!l && r.fn !== null) {
+        o ? r.f ^= h : (f & D) !== 0 ? e.push(r) : Y(r) && ((f & x) !== 0 && this.#e.add(r), y(r));
+        var a = r.first;
+        if (a !== null) {
+          r = a;
           continue;
         }
       }
-      var c = f.parent;
-      for (f = f.next; f === null && c !== null; )
-        c === t.effect && (this.#e(t.effects), this.#e(t.render_effects), this.#e(t.block_effects), t = /** @type {EffectTarget} */
-        t.parent), f = c.next, c = c.parent;
+      for (; r !== null; ) {
+        var _ = r.next;
+        if (_ !== null) {
+          r = _;
+          break;
+        }
+        r = r.parent;
+      }
     }
   }
   /**
    * @param {Effect[]} effects
    */
-  #e(e) {
-    for (const t of e)
-      ((t.f & E) !== 0 ? this.#r : this.#n).push(t), this.#c(t.deps), m(t, d);
-  }
-  /**
-   * @param {Value[] | null} deps
-   */
-  #c(e) {
-    if (e !== null)
-      for (const t of e)
-        (t.f & g) === 0 || (t.f & D) === 0 || (t.f ^= D, this.#c(
-          /** @type {Derived} */
-          t.deps
-        ));
+  #d(t) {
+    for (var e = 0; e < t.length; e += 1)
+      $(t[e], this.#r, this.#e);
   }
   /**
    * Associate a change to a given source with the current
    * batch, noting its previous and current values
    * @param {Source} source
-   * @param {any} value
+   * @param {any} old_value
    */
-  capture(e, t) {
-    this.previous.has(e) || this.previous.set(e, t), (e.f & V) === 0 && (this.current.set(e, e.v), _?.set(e, e.v));
+  capture(t, e) {
+    e !== tt && !this.previous.has(t) && this.previous.set(t, e), (t.f & j) === 0 && (this.current.set(t, t.v), m?.set(t, t.v));
   }
   activate() {
-    l = this, this.apply();
+    u = this;
   }
   deactivate() {
-    l === this && (l = null, _ = null);
+    u = null, m = null;
   }
   flush() {
-    if (this.activate(), u.length > 0) {
-      if (X(), l !== null && l !== this)
-        return;
-    } else this.#t === 0 && this.process([]);
-    this.deactivate();
+    try {
+      b = !0, u = this, this.#h();
+    } finally {
+      M = 0, C = null, E = null, R = null, b = !1, u = null, m = null, L.clear();
+    }
   }
   discard() {
-    for (const e of this.#i) e(this);
-    this.#i.clear();
+    for (const t of this.#n) t(this);
+    this.#n.clear();
   }
-  #u() {
-    if (this.#f === 0) {
-      for (const e of this.#s) e();
-      this.#s.clear();
-    }
-    this.#t === 0 && this.#a();
-  }
-  #a() {
-    if (p.size > 1) {
-      this.previous.clear();
-      var e = _, t = !0, f = {
-        parent: null,
-        effect: null,
-        effects: [],
-        render_effects: [],
-        block_effects: []
-      };
-      for (const i of p) {
-        if (i === this) {
-          t = !1;
-          continue;
-        }
-        const o = [];
-        for (const [n, c] of this.current) {
-          if (i.current.has(n))
-            if (t && c !== i.current.get(n))
-              i.current.set(n, c);
-            else
-              continue;
-          o.push(n);
-        }
-        if (o.length === 0)
-          continue;
-        const a = [...i.current.keys()].filter((n) => !this.current.has(n));
-        if (a.length > 0) {
-          var s = u;
-          u = [];
-          const n = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
-          for (const w of o)
-            x(w, a, n, c);
-          if (u.length > 0) {
-            l = i, i.apply();
-            for (const w of u)
-              i.#o(w, f);
-            i.deactivate();
+  #p() {
+    for (const l of p) {
+      var t = l.id < this.id, e = [];
+      for (const [a, _] of this.current) {
+        if (l.current.has(a))
+          if (t && _ !== l.current.get(a))
+            l.current.set(a, _);
+          else
+            continue;
+        e.push(a);
+      }
+      if (e.length !== 0) {
+        var i = [...l.current.keys()].filter((a) => !this.current.has(a));
+        if (i.length > 0) {
+          l.activate();
+          var r = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Map();
+          for (var o of e)
+            q(o, i, r, f);
+          if (l.#t.length > 0) {
+            l.apply();
+            for (var n of l.#t)
+              l.#c(n, [], []);
+            l.#t = [];
           }
-          u = s;
+          l.deactivate();
         }
       }
-      l = null, _ = e;
     }
-    this.committed = !0, p.delete(this);
   }
   /**
    *
    * @param {boolean} blocking
    */
-  increment(e) {
-    this.#t += 1, e && (this.#f += 1);
+  increment(t) {
+    this.#l += 1, t && (this.#f += 1);
   }
   /**
-   *
    * @param {boolean} blocking
+   * @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
    */
-  decrement(e) {
-    this.#t -= 1, e && (this.#f -= 1), this.revive();
+  decrement(t, e) {
+    this.#l -= 1, t && (this.#f -= 1), !(this.#o || e) && (this.#o = !0, k(() => {
+      this.#o = !1, this.flush();
+    }));
   }
-  revive() {
-    for (const e of this.#r)
-      m(e, E), R(e);
-    for (const e of this.#n)
-      m(e, z), R(e);
-    this.#r = [], this.#n = [], this.flush();
+  /**
+   * @param {Set<Effect>} dirty_effects
+   * @param {Set<Effect>} maybe_dirty_effects
+   */
+  transfer_effects(t, e) {
+    for (const i of t)
+      this.#r.add(i);
+    for (const i of e)
+      this.#e.add(i);
+    t.clear(), e.clear();
   }
-  /** @param {() => void} fn */
-  oncommit(e) {
-    this.#s.add(e);
+  /** @param {(batch: Batch) => void} fn */
+  oncommit(t) {
+    this.#s.add(t);
   }
   /** @param {(batch: Batch) => void} fn */
-  ondiscard(e) {
-    this.#i.add(e);
+  ondiscard(t) {
+    this.#n.add(t);
   }
   settled() {
-    return (this.#l ??= U()).promise;
+    return (this.#u ??= Z()).promise;
   }
   static ensure() {
-    if (l === null) {
-      const e = l = new k();
-      p.add(l), k.enqueue(() => {
-        l === e && e.flush();
-      });
+    if (u === null) {
+      const t = u = new A();
+      b || (p.add(u), k(() => {
+        u === t && t.flush();
+      }));
     }
-    return l;
-  }
-  /** @param {() => void} task */
-  static enqueue(e) {
-    J(e);
+    return u;
   }
   apply() {
+    {
+      m = null;
+      return;
+    }
   }
-}
-function X() {
-  var r = W;
-  F = !0;
-  var e = null;
-  try {
-    var t = 0;
-    for (A(!0); u.length > 0; ) {
-      var f = k.ensure();
-      if (t++ > 1e3) {
-        var s, i;
-        Z();
+  /**
+   *
+   * @param {Effect} effect
+   */
+  schedule(t) {
+    if (C = t, t.b?.is_pending && (t.f & (D | z | G)) !== 0 && (t.f & H) === 0) {
+      t.b.defer_effect(t);
+      return;
+    }
+    for (var e = t; e.parent !== null; ) {
+      e = e.parent;
+      var i = e.f;
+      if (E !== null && e === P && (S === null || (S.f & N) === 0))
+        return;
+      if ((i & (I | F)) !== 0) {
+        if ((i & h) === 0)
+          return;
+        e.f ^= h;
       }
-      f.process(u), N.clear();
     }
-  } finally {
-    F = !1, A(r), C = null;
+    this.#t.push(e);
   }
 }
-function Z() {
+function it() {
   try {
-    G();
-  } catch (r) {
-    P(r, C);
+    Q();
+  } catch (s) {
+    W(s, C);
   }
 }
-let h = null;
-function O(r) {
-  var e = r.length;
-  if (e !== 0) {
-    for (var t = 0; t < e; ) {
-      var f = r[t++];
-      if ((f.f & (b | v)) === 0 && M(f) && (h = /* @__PURE__ */ new Set(), y(f), f.deps === null && f.first === null && f.nodes === null && (f.teardown === null && f.ac === null ? Q(f) : f.fn = null), h?.size > 0)) {
-        N.clear();
-        for (const s of h) {
-          if ((s.f & (b | v)) !== 0) continue;
-          const i = [s];
-          let o = s.parent;
+let c = null;
+function O(s) {
+  var t = s.length;
+  if (t !== 0) {
+    for (var e = 0; e < t; ) {
+      var i = s[e++];
+      if ((i.f & (g | w)) === 0 && Y(i) && (c = /* @__PURE__ */ new Set(), y(i), i.deps === null && i.first === null && i.nodes === null && i.teardown === null && i.ac === null && X(i), c?.size > 0)) {
+        L.clear();
+        for (const r of c) {
+          if ((r.f & (g | w)) !== 0) continue;
+          const f = [r];
+          let o = r.parent;
           for (; o !== null; )
-            h.has(o) && (h.delete(o), i.push(o)), o = o.parent;
-          for (let a = i.length - 1; a >= 0; a--) {
-            const n = i[a];
-            (n.f & (b | v)) === 0 && y(n);
+            c.has(o) && (c.delete(o), f.push(o)), o = o.parent;
+          for (let n = f.length - 1; n >= 0; n--) {
+            const l = f[n];
+            (l.f & (g | w)) === 0 && y(l);
           }
         }
-        h.clear();
+        c.clear();
       }
     }
-    h = null;
+    c = null;
   }
 }
-function x(r, e, t, f) {
-  if (!t.has(r) && (t.add(r), r.reactions !== null))
-    for (const s of r.reactions) {
-      const i = s.f;
-      (i & g) !== 0 ? x(
+function q(s, t, e, i) {
+  if (!e.has(s) && (e.add(s), s.reactions !== null))
+    for (const r of s.reactions) {
+      const f = r.f;
+      (f & N) !== 0 ? q(
         /** @type {Derived} */
-        s,
-        e,
+        r,
         t,
-        f
-      ) : (i & (H | T)) !== 0 && (i & E) === 0 && I(s, e, f) && (m(s, E), R(
+        e,
+        i
+      ) : (f & (K | x)) !== 0 && (f & v) === 0 && B(r, t, i) && (d(r, v), rt(
         /** @type {Effect} */
-        s
+        r
       ));
     }
 }
-function I(r, e, t) {
-  const f = t.get(r);
-  if (f !== void 0) return f;
-  if (r.deps !== null)
-    for (const s of r.deps) {
-      if (e.includes(s))
+function B(s, t, e) {
+  const i = e.get(s);
+  if (i !== void 0) return i;
+  if (s.deps !== null)
+    for (const r of s.deps) {
+      if (J.call(t, r))
         return !0;
-      if ((s.f & g) !== 0 && I(
+      if ((r.f & N) !== 0 && B(
         /** @type {Derived} */
-        s,
-        e,
-        t
+        r,
+        t,
+        e
       ))
-        return t.set(
+        return e.set(
           /** @type {Derived} */
-          s,
+          r,
           !0
         ), !0;
     }
-  return t.set(r, !1), !1;
+  return e.set(s, !1), !1;
 }
-function R(r) {
-  for (var e = C = r; e.parent !== null; ) {
-    e = e.parent;
-    var t = e.f;
-    if (F && e === j && (t & T) !== 0 && (t & K) === 0)
-      return;
-    if ((t & (q | Y)) !== 0) {
-      if ((t & d) === 0) return;
-      e.f ^= d;
-    }
+function rt(s) {
+  u.schedule(s);
+}
+function U(s, t) {
+  if (!((s.f & F) !== 0 && (s.f & h) !== 0)) {
+    (s.f & v) !== 0 ? t.d.push(s) : (s.f & T) !== 0 && t.m.push(s), d(s, h);
+    for (var e = s.first; e !== null; )
+      U(e, t), e = e.next;
   }
-  u.push(e);
+}
+function V(s) {
+  d(s, h);
+  for (var t = s.first; t !== null; )
+    V(t), t = t.next;
 }
 export {
-  k as Batch,
-  _ as batch_values,
-  l as current_batch,
-  h as eager_block_effects,
-  R as schedule_effect
+  A as Batch,
+  m as batch_values,
+  E as collected_effects,
+  u as current_batch,
+  c as eager_block_effects,
+  R as legacy_updates,
+  rt as schedule_effect
 };