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

package/esm/svelte/svelte/src/internal/client/dom/blocks/boundary.js

@@ -1,46 +1,55 @@
-import { EFFECT_TRANSPARENT as y, EFFECT_PRESERVED as b, BOUNDARY_EFFECT as E } from "../../constants.js";
-import { set_component_context as p, component_context as F } from "../../context.js";
-import { handle_error as x, invoke_error_boundary as d } from "../../error-handling.js";
-import { block as R, branch as r, pause_effect as f, move_effect as T, destroy_effect as l } from "../../reactivity/effects.js";
-import { active_effect as c, set_active_effect as m, set_active_reaction as h, active_reaction as g, get as k } from "../../runtime.js";
-import { svelte_boundary_reset_noop as w } from "../../warnings.js";
+import { BOUNDARY_EFFECT as m, EFFECT_TRANSPARENT as E, EFFECT_PRESERVED as F } from "../../constants.js";
+import { set_component_context as g, component_context as x } from "../../context.js";
+import { handle_error as R, invoke_error_boundary as a } from "../../error-handling.js";
+import { block as S, branch as h, pause_effect as _, move_effect as T, destroy_effect as u } from "../../reactivity/effects.js";
+import { active_effect as c, set_active_effect as v, set_active_reaction as y, active_reaction as w, get as D } from "../../runtime.js";
+import { svelte_boundary_reset_noop as k } from "../../warnings.js";
 import { create_text as A } from "../operations.js";
-import { queue_micro_task as B } from "../task.js";
-import { svelte_boundary_reset_onerror as C } from "../../errors.js";
-import { Batch as o } from "../../reactivity/batch.js";
-import { internal_set as D, source as N } from "../../reactivity/sources.js";
-import { createSubscriber as S } from "../../../../reactivity/create-subscriber.js";
-var q = y | b | E;
-function M(u, t, i) {
-  new P(u, t, i);
+import { queue_micro_task as l } from "../task.js";
+import { svelte_boundary_reset_onerror as B } from "../../errors.js";
+import { current_batch as b, Batch as C } from "../../reactivity/batch.js";
+import { internal_set as N, source as q } from "../../reactivity/sources.js";
+import { createSubscriber as P } from "../../../../reactivity/create-subscriber.js";
+import { defer_effect as j } from "../../reactivity/utils.js";
+var O = E | F;
+function Z(p, t, e, r) {
+  new U(p, t, e, r);
 }
-class P {
+class U {
   /** @type {Boundary | null} */
   parent;
-  #i = !1;
+  is_pending = !1;
+  /**
+   * API-level transformError transform function. Transforms errors before they reach the `failed` snippet.
+   * Inherited from parent boundary, or defaults to identity.
+   * @type {(error: unknown) => unknown}
+   */
+  transform_error;
   /** @type {TemplateNode} */
-  #e;
+  #r;
   /** @type {TemplateNode | null} */
   #y = null;
   /** @type {BoundaryProps} */
-  #r;
+  #s;
   /** @type {((anchor: Node) => void)} */
-  #c;
+  #a;
   /** @type {Effect} */
-  #n;
+  #t;
   /** @type {Effect | null} */
-  #s = null;
+  #n = null;
   /** @type {Effect | null} */
-  #t = null;
+  #e = null;
   /** @type {Effect | null} */
-  #h = null;
+  #i = null;
   /** @type {DocumentFragment | null} */
-  #o = null;
-  /** @type {TemplateNode | null} */
-  #a = null;
-  #u = 0;
+  #h = null;
+  #c = 0;
   #f = 0;
   #_ = !1;
+  /** @type {Set<Effect>} */
+  #p = /* @__PURE__ */ new Set();
+  /** @type {Set<Effect>} */
+  #d = /* @__PURE__ */ new Set();
   /**
    * A source containing the number of pending async deriveds/expressions.
    * Only created if `$effect.pending()` is used inside the boundary,
@@ -48,171 +57,221 @@ class P {
    * calls followed by no-op flushes
    * @type {Source<number> | null}
    */
-  #l = null;
-  #v = S(() => (this.#l = N(this.#u), () => {
-    this.#l = null;
+  #o = null;
+  #v = P(() => (this.#o = q(this.#c), () => {
+    this.#o = null;
   }));
   /**
    * @param {TemplateNode} node
    * @param {BoundaryProps} props
    * @param {((anchor: Node) => void)} children
+   * @param {((error: unknown) => unknown) | undefined} [transform_error]
    */
-  constructor(t, i, e) {
-    this.#e = t, this.#r = i, this.#c = e, this.parent = /** @type {Effect} */
-    c.b, this.#i = !!this.#r.pending, this.#n = R(() => {
-      c.b = this;
-      {
-        var n = this.#m();
-        try {
-          this.#s = r(() => e(n));
-        } catch (s) {
-          this.error(s);
-        }
-        this.#f > 0 ? this.#d() : this.#i = !1;
-      }
-      return () => {
-        this.#a?.remove();
-      };
-    }, q);
+  constructor(t, e, r, o) {
+    this.#r = t, this.#s = e, this.#a = (s) => {
+      var f = (
+        /** @type {Effect} */
+        c
+      );
+      f.b = this, f.f |= m, r(s);
+    }, this.parent = /** @type {Effect} */
+    c.b, this.transform_error = o ?? this.parent?.transform_error ?? ((s) => s), this.#t = S(() => {
+      this.#m();
+    }, O);
   }
   #b() {
     try {
-      this.#s = r(() => this.#c(this.#e));
+      this.#n = h(() => this.#a(this.#r));
     } catch (t) {
       this.error(t);
     }
-    this.#i = !1;
   }
-  #E() {
-    const t = this.#r.pending;
-    t && (this.#t = r(() => t(this.#e)), o.enqueue(() => {
-      var i = this.#m();
-      this.#s = this.#p(() => (o.ensure(), r(() => this.#c(i)))), this.#f > 0 ? this.#d() : (f(
+  /**
+   * @param {unknown} error The deserialized error from the server's hydration comment
+   */
+  #E(t) {
+    const e = this.#s.failed;
+    e && (this.#i = h(() => {
+      e(
+        this.#r,
+        () => t,
+        () => () => {
+        }
+      );
+    }));
+  }
+  #F() {
+    const t = this.#s.pending;
+    t && (this.is_pending = !0, this.#e = h(() => t(this.#r)), l(() => {
+      var e = this.#h = document.createDocumentFragment(), r = A();
+      e.append(r), this.#n = this.#l(() => h(() => this.#a(r))), this.#f === 0 && (this.#r.before(e), this.#h = null, _(
         /** @type {Effect} */
-        this.#t,
+        this.#e,
         () => {
-          this.#t = null;
+          this.#e = null;
         }
-      ), this.#i = !1);
+      ), this.#u(
+        /** @type {Batch} */
+        b
+      ));
     }));
   }
   #m() {
-    var t = this.#e;
-    return this.#i && (this.#a = A(), this.#e.before(this.#a), t = this.#a), t;
+    try {
+      if (this.is_pending = this.has_pending_snippet(), this.#f = 0, this.#c = 0, this.#n = h(() => {
+        this.#a(this.#r);
+      }), this.#f > 0) {
+        var t = this.#h = document.createDocumentFragment();
+        T(this.#n, t);
+        const e = (
+          /** @type {(anchor: Node) => void} */
+          this.#s.pending
+        );
+        this.#e = h(() => e(this.#r));
+      } else
+        this.#u(
+          /** @type {Batch} */
+          b
+        );
+    } catch (e) {
+      this.error(e);
+    }
   }
   /**
-   * Returns `true` if the effect exists inside a boundary whose pending snippet is shown
+   * @param {Batch} batch
+   */
+  #u(t) {
+    this.is_pending = !1, t.transfer_effects(this.#p, this.#d);
+  }
+  /**
+   * Defer an effect inside a pending boundary until the boundary resolves
+   * @param {Effect} effect
+   */
+  defer_effect(t) {
+    j(t, this.#p, this.#d);
+  }
+  /**
+   * Returns `false` if the effect exists inside a boundary whose pending snippet is shown
    * @returns {boolean}
    */
-  is_pending() {
-    return this.#i || !!this.parent && this.parent.is_pending();
+  is_rendered() {
+    return !this.is_pending && (!this.parent || this.parent.is_rendered());
   }
   has_pending_snippet() {
-    return !!this.#r.pending;
+    return !!this.#s.pending;
   }
   /**
-   * @param {() => Effect | null} fn
+   * @template T
+   * @param {() => T} fn
    */
-  #p(t) {
-    var i = c, e = g, n = F;
-    m(this.#n), h(this.#n), p(this.#n.ctx);
+  #l(t) {
+    var e = c, r = w, o = x;
+    v(this.#t), y(this.#t), g(this.#t.ctx);
     try {
-      return t();
+      return C.ensure(), t();
     } catch (s) {
-      return x(s), null;
+      return R(s), null;
     } finally {
-      m(i), h(e), p(n);
+      v(e), y(r), g(o);
     }
   }
-  #d() {
-    const t = (
-      /** @type {(anchor: Node) => void} */
-      this.#r.pending
-    );
-    this.#s !== null && (this.#o = document.createDocumentFragment(), this.#o.append(
-      /** @type {TemplateNode} */
-      this.#a
-    ), T(this.#s, this.#o)), this.#t === null && (this.#t = r(() => t(this.#e)));
-  }
   /**
    * Updates the pending count associated with the currently visible pending snippet,
    * if any, such that we can replace the snippet with content once work is done
    * @param {1 | -1} d
+   * @param {Batch} batch
    */
-  #g(t) {
+  #g(t, e) {
     if (!this.has_pending_snippet()) {
-      this.parent && this.parent.#g(t);
+      this.parent && this.parent.#g(t, e);
       return;
     }
-    this.#f += t, this.#f === 0 && (this.#i = !1, this.#t && f(this.#t, () => {
-      this.#t = null;
-    }), this.#o && (this.#e.before(this.#o), this.#o = null));
+    this.#f += t, this.#f === 0 && (this.#u(e), this.#e && _(this.#e, () => {
+      this.#e = null;
+    }), this.#h && (this.#r.before(this.#h), this.#h = null));
   }
   /**
    * Update the source that powers `$effect.pending()` inside this boundary,
    * and controls when the current `pending` snippet (if any) is removed.
    * Do not call from inside the class
    * @param {1 | -1} d
+   * @param {Batch} batch
    */
-  update_pending_count(t) {
-    this.#g(t), this.#u += t, this.#l && D(this.#l, this.#u);
+  update_pending_count(t, e) {
+    this.#g(t, e), this.#c += t, !(!this.#o || this.#_) && (this.#_ = !0, l(() => {
+      this.#_ = !1, this.#o && N(this.#o, this.#c);
+    }));
   }
   get_effect_pending() {
-    return this.#v(), k(
+    return this.#v(), D(
       /** @type {Source<number>} */
-      this.#l
+      this.#o
     );
   }
   /** @param {unknown} error */
   error(t) {
-    var i = this.#r.onerror;
-    let e = this.#r.failed;
-    if (this.#_ || !i && !e)
+    var e = this.#s.onerror;
+    let r = this.#s.failed;
+    if (!e && !r)
       throw t;
-    this.#s && (l(this.#s), this.#s = null), this.#t && (l(this.#t), this.#t = null), this.#h && (l(this.#h), this.#h = null);
-    var n = !1, s = !1;
-    const _ = () => {
-      if (n) {
-        w();
+    this.#n && (u(this.#n), this.#n = null), this.#e && (u(this.#e), this.#e = null), this.#i && (u(this.#i), this.#i = null);
+    var o = !1, s = !1;
+    const f = () => {
+      if (o) {
+        k();
         return;
       }
-      n = !0, s && C(), o.ensure(), this.#u = 0, this.#h !== null && f(this.#h, () => {
-        this.#h = null;
-      }), this.#i = this.has_pending_snippet(), this.#s = this.#p(() => (this.#_ = !1, r(() => this.#c(this.#e)))), this.#f > 0 ? this.#d() : this.#i = !1;
-    };
-    var v = g;
-    try {
-      h(null), s = !0, i?.(t, _), s = !1;
-    } catch (a) {
-      d(a, this.#n && this.#n.parent);
-    } finally {
-      h(v);
-    }
-    e && B(() => {
-      this.#h = this.#p(() => {
-        o.ensure(), this.#_ = !0;
+      o = !0, s && B(), this.#i !== null && _(this.#i, () => {
+        this.#i = null;
+      }), this.#l(() => {
+        this.#m();
+      });
+    }, d = (n) => {
+      try {
+        s = !0, e?.(n, f), s = !1;
+      } catch (i) {
+        a(i, this.#t && this.#t.parent);
+      }
+      r && (this.#i = this.#l(() => {
         try {
-          return r(() => {
-            e(
-              this.#e,
-              () => t,
-              () => _
+          return h(() => {
+            var i = (
+              /** @type {Effect} */
+              c
+            );
+            i.b = this, i.f |= m, r(
+              this.#r,
+              () => n,
+              () => f
             );
           });
-        } catch (a) {
-          return d(
-            a,
+        } catch (i) {
+          return a(
+            i,
             /** @type {Effect} */
-            this.#n.parent
+            this.#t.parent
           ), null;
-        } finally {
-          this.#_ = !1;
         }
-      });
+      }));
+    };
+    l(() => {
+      var n;
+      try {
+        n = this.transform_error(t);
+      } catch (i) {
+        a(i, this.#t && this.#t.parent);
+        return;
+      }
+      n !== null && typeof n == "object" && typeof /** @type {any} */
+      n.then == "function" ? n.then(
+        d,
+        /** @param {unknown} e */
+        (i) => a(i, this.#t && this.#t.parent)
+      ) : d(n);
     });
   }
 }
 export {
-  P as Boundary,
-  M as boundary
+  U as Boundary,
+  Z as boundary
 };

package/esm/svelte/svelte/src/internal/client/dom/blocks/branches.js

@@ -1,6 +1,6 @@
-import { current_batch as n } from "../../reactivity/batch.js";
-import { resume_effect as p, destroy_effect as a, pause_effect as m, branch as d, move_effect as u } from "../../reactivity/effects.js";
-import { create_text as l, should_defer_append as v } from "../operations.js";
+import { current_batch as l } from "../../reactivity/batch.js";
+import { resume_effect as u, destroy_effect as n, pause_effect as m, branch as a, move_effect as p } from "../../reactivity/effects.js";
+import { create_text as d, should_defer_append as _ } from "../operations.js";
 class w {
   /** @type {TemplateNode} */
   anchor;
@@ -41,84 +41,83 @@ class w {
    * @param {TemplateNode} anchor
    * @param {boolean} transition
    */
-  constructor(e, s = !0) {
-    this.anchor = e, this.#f = s;
+  constructor(t, s = !0) {
+    this.anchor = t, this.#f = s;
   }
-  #r = () => {
-    var e = (
-      /** @type {Batch} */
-      n
-    );
-    if (this.#t.has(e)) {
+  /**
+   * @param {Batch} batch
+   */
+  #r = (t) => {
+    if (this.#t.has(t)) {
       var s = (
         /** @type {Key} */
-        this.#t.get(e)
-      ), t = this.#s.get(s);
-      if (t)
-        p(t), this.#i.delete(s);
+        this.#t.get(t)
+      ), e = this.#s.get(s);
+      if (e)
+        u(e), this.#i.delete(s);
       else {
         var f = this.#e.get(s);
-        f && (this.#s.set(s, f.effect), this.#e.delete(s), f.fragment.lastChild.remove(), this.anchor.before(f.fragment), t = f.effect);
+        f && (this.#s.set(s, f.effect), this.#e.delete(s), f.fragment.lastChild.remove(), this.anchor.before(f.fragment), e = f.effect);
       }
       for (const [i, r] of this.#t) {
-        if (this.#t.delete(i), i === e)
+        if (this.#t.delete(i), i === t)
           break;
         const c = this.#e.get(r);
-        c && (a(c.effect), this.#e.delete(r));
+        c && (n(c.effect), this.#e.delete(r));
       }
       for (const [i, r] of this.#s) {
         if (i === s || this.#i.has(i)) continue;
         const c = () => {
           if (Array.from(this.#t.values()).includes(i)) {
-            var o = document.createDocumentFragment();
-            u(r, o), o.append(l()), this.#e.set(i, { effect: r, fragment: o });
+            var h = document.createDocumentFragment();
+            p(r, h), h.append(d()), this.#e.set(i, { effect: r, fragment: h });
           } else
-            a(r);
+            n(r);
           this.#i.delete(i), this.#s.delete(i);
         };
-        this.#f || !t ? (this.#i.add(i), m(r, c, !1)) : c();
+        this.#f || !e ? (this.#i.add(i), m(r, c, !1)) : c();
       }
     }
   };
   /**
    * @param {Batch} batch
    */
-  #c = (e) => {
-    this.#t.delete(e);
+  #c = (t) => {
+    this.#t.delete(t);
     const s = Array.from(this.#t.values());
-    for (const [t, f] of this.#e)
-      s.includes(t) || (a(f.effect), this.#e.delete(t));
+    for (const [e, f] of this.#e)
+      s.includes(e) || (n(f.effect), this.#e.delete(e));
   };
   /**
    *
    * @param {any} key
    * @param {null | ((target: TemplateNode) => void)} fn
    */
-  ensure(e, s) {
-    var t = (
+  ensure(t, s) {
+    var e = (
       /** @type {Batch} */
-      n
-    ), f = v();
-    if (s && !this.#s.has(e) && !this.#e.has(e))
+      l
+    ), f = _();
+    if (s && !this.#s.has(t) && !this.#e.has(t))
       if (f) {
-        var i = document.createDocumentFragment(), r = l();
-        i.append(r), this.#e.set(e, {
-          effect: d(() => s(r)),
+        var i = document.createDocumentFragment(), r = d();
+        i.append(r), this.#e.set(t, {
+          effect: a(() => s(r)),
           fragment: i
         });
       } else
         this.#s.set(
-          e,
-          d(() => s(this.anchor))
+          t,
+          a(() => s(this.anchor))
         );
-    if (this.#t.set(t, e), f) {
-      for (const [c, h] of this.#s)
-        c === e ? t.skipped_effects.delete(h) : t.skipped_effects.add(h);
-      for (const [c, h] of this.#e)
-        c === e ? t.skipped_effects.delete(h.effect) : t.skipped_effects.add(h.effect);
-      t.oncommit(this.#r), t.ondiscard(this.#c);
+    if (this.#t.set(e, t), f) {
+      for (const [c, o] of this.#s)
+        c === t ? e.unskip_effect(o) : e.skip_effect(o);
+      for (const [c, o] of this.#e)
+        c === t ? e.unskip_effect(o.effect) : e.skip_effect(o.effect);
+      e.oncommit(this.#r), e.ondiscard(this.#c);
     } else
-      this.#r();
+      this.#r(e);
   }
 }
 export {