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

package/esm/core/extensionManager.js

@@ -1,201 +1,204 @@
 /*!
-* FilePond v5.0.0-beta.2
+* FilePond v5.0.0-beta.21
 * Copyright (c) 2017-2026 Pqina B.V.
 * Released under the MIT License
 * https://filepond.com
 */
-import { createTaskScheduler as F } from "./taskScheduler.js";
-import { pubsub as R } from "../utils/pubsub.js";
+import { createTaskScheduler as R } from "./taskScheduler.js";
+import { pubsub as z } from "../utils/pubsub.js";
 import { isArray as k } from "../utils/test.js";
-import { arrayItemsEqual as w, arrayRemoveInPlace as z, arraySortByItemProp as D } from "../utils/array.js";
-function Q(c) {
-  const { on: I, pub: y } = R(), i = [], { insertEntries: T, replaceEntry: A, updateEntry: v, removeEntries: j } = c, u = F({ logState: !1 }), f = {
+import { arrayItemsEqual as D, arrayRemoveInPlace as G, arraySortByItemProp as H } from "../utils/array.js";
+function V(a) {
+  const { on: I, pub: y } = z(), c = [], { insertEntries: T, replaceEntry: A, updateEntry: v, removeEntries: j } = a, f = R({ log: void 0 }), x = {
     extension: {}
   };
-  function l(n, e) {
-    f.extension[n] = {
+  function l(n, s) {
+    x.extension[n] = {
       ...g(n),
-      ...e
-    }, y("update", f.extension);
+      ...s
+    }, y("update", x.extension);
   }
   function g(n) {
-    return f.extension[n] ?? {};
+    return x.extension[n] ?? {};
   }
-  function C(n, e) {
-    l(n, { status: e });
+  function C(n, s) {
+    l(n, { status: s });
   }
   function O(n) {
-    return f.extension[n].status;
+    return x.extension[n].status;
   }
-  c.on("removeEntry", ({ entry: n }) => {
-    u.abortTasks(n.id);
+  a.on("removeEntry", ({ entry: n }) => {
+    f.abortTasks(n.id);
   });
   function q(n) {
-    const e = function(s, a) {
-      return c.on(s, a);
+    const s = function(e, i) {
+      return a.on(e, i);
     }, o = [], t = { current: void 0 };
     t.current = n({
       // events
-      on: e,
+      on: s,
       // get root extension state
-      setExtensionState: r((s) => {
-        l(t.current.name, s);
+      setExtensionState: r((e) => {
+        l(t.current.name, e);
       }),
       getExtensionState: r(() => g(t.current.name)),
       // get root extension status
       setExtensionStatus: r(
-        (s) => C(t.current.name, s)
+        (e) => C(t.current.name, e)
       ),
       // @ts-ignore
       getExtensionStatus: r(() => O(t.current.name)),
-      pushTask: function(s, a, p) {
+      pushTask: function(e, i, u) {
         const B = E(
           t.current.name
         );
-        c.findEntries(s) && u.pushTask(s, a, {
+        a.findEntries(e) && f.pushTask(e, i, {
           // set order to factor of 100 so in theory there's plenty room for adding manual order
           order: B.index * 100,
           // when params is a function it is called on run task
-          params: () => [c.findEntries(s)],
+          params: () => [a.findEntries(e)],
           // add custom options
-          ...p
+          ...u
         });
       },
-      abortTask: function(s, a) {
-        u.abortTask(s, a);
+      abortTask: function(e, i) {
+        f.abortTask(e, i);
       },
-      abortTasks: (s) => {
-        u.abortTasks(s);
+      abortTasks: (e) => {
+        f.abortTasks(e);
       },
-      setEntries: function(s) {
-        c.entries = s;
+      setEntries: function(e) {
+        a.entries = e;
       },
-      getEntries: () => c.entries,
+      getEntries: () => a.entries,
       // manipulating entry list
       insertEntries: T,
       removeEntries: j,
       replaceEntry: A,
       updateEntry: v
     });
-    function r(s) {
-      return (...a) => {
+    function r(e) {
+      return (...i) => {
         if (t.current) {
-          s(...a);
+          e(...i);
           return;
         }
-        o.push([s, a]);
+        o.push([e, i]);
       };
     }
-    return o.forEach(([s, a]) => {
-      s(...a);
+    return o.forEach(([e, i]) => {
+      e(...i);
     }), t.current;
   }
-  function S() {
-    u.abortTasks(), i.map((n) => n.instance).forEach((n) => n.destroy()), i.length = 0;
+  function h() {
+    f.abortTasks(), c.map((n) => n.instance).forEach((n) => n.destroy()), c.length = 0;
   }
-  const h = {
+  const S = {
     // subscribe to events
     on: I,
     get extensions() {
-      return i.map(({ factory: n }) => n);
+      return c.map(({ factory: n }) => n);
     },
     set extensions(n) {
       if (!k(n))
         return;
-      const e = n.map(
+      const s = n.map(
         (t) => Array.isArray(t) ? t[0] : t
       );
-      if (w(e, h.extensions)) {
+      if (D(s, S.extensions)) {
         for (const t of n) {
           if (!k(t))
             continue;
-          const r = i.find((s) => t[0] === s.factory);
-          d(r, t[1]);
+          const r = c.find((e) => t[0] === e.factory);
+          p(r, t[1]);
         }
         return;
       }
-      n.length === 0 && (x.clear(), S());
-      for (const t of i)
-        if (!e.includes(t.factory)) {
-          t.instance.destroy(), z(i, (r) => r === t);
+      n.length === 0 && (d.clear(), h());
+      for (const t of c)
+        if (!s.includes(t.factory)) {
+          t.instance.destroy(), G(c, (r) => r === t);
           continue;
         }
-      for (const [t, r] of Object.entries(e)) {
-        const s = parseInt(t, 10), a = i.find((p) => r === p.factory);
-        if (a) {
-          a.index = s;
+      for (const [t, r] of Object.entries(s)) {
+        const e = parseInt(t, 10), i = c.find((u) => r === u.factory);
+        if (i) {
+          if (i.index = e, Array.isArray(n[e])) {
+            const u = n[e][1];
+            p(i, u);
+          }
           continue;
         }
-        if (i.push({
-          index: s,
+        if (c.push({
+          index: e,
           factory: r,
           instance: q(r)
-        }), Array.isArray(n[s])) {
-          const p = n[s][1];
-          d(i.at(-1), p);
+        }), Array.isArray(n[e])) {
+          const u = n[e][1];
+          p(c.at(-1), u);
         }
       }
-      D(i, "index"), Object.entries(x.get("*") ?? []).forEach(
+      H(c, "index"), Object.entries(d.get("*") ?? []).forEach(
         ([t, r]) => {
           P(t, r);
         }
       );
-      for (const [t, r] of x)
+      for (const [t, r] of d)
         t !== "*" && b(t, r);
-      const o = i.map((t) => t.instance.name);
-      y("setExtensions", { extensionNames: o }), c.entries = [...c.entries];
+      const o = c.map((t) => t.instance.name);
+      y("setExtensions", { extensionNames: o }), a.entries = [...a.entries];
     },
     propagateExtensionProperty: P,
     setExtensionProperties: b,
     getExtensionProperties: M,
     // access manager state
     getState() {
-      return f.extension;
+      return x.extension;
     },
     // destroy FilePond instance
     destroy() {
-      S();
+      h();
     }
   };
-  function P(n, e) {
-    const o = { [n]: e }, t = W(n);
+  function P(n, s) {
+    const o = { [n]: s }, t = W(n);
     for (const r of t)
-      d(r, o);
+      p(r, o);
     m("*", o);
   }
-  function b(n, e) {
+  function b(n, s) {
     const o = E(n);
-    o ? d(o, e) : m(n, e);
+    o ? p(o, s) : m(n, s);
   }
   function M(n) {
-    const e = E(n);
-    if (!e)
+    const s = E(n);
+    if (!s)
       return;
-    const { instance: o } = e;
+    const { instance: o } = s;
     if (o)
       return o.getProps();
   }
-  function d(n, e) {
-    e && (n.instance.setProps(e), m(n.instance.name, e));
+  function p(n, s) {
+    s && (n.instance.setProps(s), m(n.instance.name, s));
   }
   function W(n) {
-    return i.filter((e) => {
-      const o = e.instance.getProps();
+    return c.filter((s) => {
+      const o = s.instance.getProps();
       return Object.keys(o).includes(n);
     });
   }
   function E(n) {
-    return i.find((e) => e.instance.name === n);
+    return c.find((s) => s.instance.name === n);
   }
-  const x = /* @__PURE__ */ new Map();
-  function m(n, e) {
-    x.set(n, {
-      ...x.get(n),
-      ...e
+  const d = /* @__PURE__ */ new Map();
+  function m(n, s) {
+    d.set(n, {
+      ...d.get(n),
+      ...s
     });
   }
-  return h;
+  return S;
 }
 export {
-  Q as createExtensionManager
+  V as createExtensionManager
 };

package/esm/core/taskScheduler.js

@@ -1,194 +1,175 @@
 /*!
-* FilePond v5.0.0-beta.2
+* FilePond v5.0.0-beta.21
 * Copyright (c) 2017-2026 Pqina B.V.
 * Released under the MIT License
 * https://filepond.com
 */
 import { arrayRemoveInPlace as T } from "../utils/array.js";
-import { pubsub as z } from "../utils/pubsub.js";
-import { isString as J, isFunction as U } from "../utils/test.js";
-import { log as p } from "../common/console.js";
+import { pubsub as j } from "../utils/pubsub.js";
+import { isString as z, isFunction as D } from "../utils/test.js";
 const e = {
   QUEUED: 1,
   ACTIVE: 2,
   FAILED: 3,
   HALTED: 4
 };
-function tt(x) {
-  const { logState: k = !1 } = x ?? {}, { on: C, pub: f } = z(), a = [], i = /* @__PURE__ */ new Map();
-  function g() {
-    p(`Tasks: ${a.length}`);
-    for (const t of a) {
-      const { group: n, fn: r, order: o, parallel: s, state: u, ...D } = t;
-      let j = {
-        // queued
-        1: "📥",
-        // active
-        2: "👉",
-        // failed
-        3: "💥",
-        // halted
-        4: "🖐️"
-      }[u];
-      p(j, n, r.name, { parallel: s, order: o });
-    }
-    p("");
-  }
-  function v(t) {
+function Y(S) {
+  const { log: p = void 0 } = S ?? {}, { on: U, pub: f } = j(), s = [], i = /* @__PURE__ */ new Map();
+  function h(t) {
     return t.state === e.QUEUED || t.state === e.ACTIVE;
   }
-  function m(t) {
+  function k(t) {
     return t.state === e.QUEUED;
   }
-  function Q(t) {
+  function x(t) {
     return t.state === e.ACTIVE;
   }
-  function B(t, n) {
-    return J(t) && U(n);
+  function C(t, n) {
+    return z(t) && D(n);
   }
-  function E(t, n) {
+  function g(t, n) {
     let r = 0;
     for (let o = 0; o < n.length; o++)
       t.order >= n[o].order && (r = o + 1);
     n.splice(r, 0, t);
   }
-  function H(t) {
-    E(t, a);
+  function v(t) {
+    g(t, s);
     let n = i.get(t.group);
-    n || (n = [], i.set(t.group, n)), E(t, n);
+    n || (n = [], i.set(t.group, n)), g(t, n);
   }
-  function L(t, n) {
+  function Q(t, n) {
     const r = i.get(t);
     return r ? !!r.find((o) => o.fn === n) : !1;
   }
-  function d(t) {
+  function m(t) {
     T(
-      a,
+      s,
       (r) => r.group === t.group && r.fn === t.fn
     );
     const n = i.get(t.group);
     n && T(n, (r) => r.fn === t.fn);
   }
-  function O(t) {
-    T(a, (n) => n.group === t), i.delete(t);
+  function B(t) {
+    T(s, (n) => n.group === t), i.delete(t);
   }
   function c(t) {
     return i.get(t) ?? [];
   }
-  function b(t, n) {
+  function E(t, n) {
     return c(t)[0].state === n;
   }
-  function V(t) {
-    return c(t).filter(v).length > 0;
+  function H(t) {
+    return c(t).filter(h).length > 0;
   }
-  function q(t) {
+  function L(t) {
     const n = c(t);
     for (const r of n)
-      S(r);
+      y(r);
   }
-  function A(t) {
-    return c(t).filter(m)[0];
+  function d(t) {
+    return c(t).filter(k)[0];
   }
-  function w(t, n) {
+  function O(t, n) {
     const r = c(t);
     if (r)
       return r.find((o) => o.fn === n);
   }
-  function I(t, n, r) {
-    const { ignoreOptional: o = !1 } = r || {}, s = i.get(t) ?? [];
-    for (const u of s)
+  function b(t, n, r) {
+    const { ignoreOptional: o = !1 } = r || {}, a = i.get(t) ?? [];
+    for (const u of a)
       o && u.isOptional || (u.state = n);
   }
-  function N() {
-    return Array.from(new Set(a.map((t) => t.group)));
+  function V() {
+    return Array.from(new Set(s.map((t) => t.group)));
   }
-  function R() {
+  function q() {
     return i.keys();
   }
-  function F() {
-    return a.filter(m).length > 0;
+  function w() {
+    return s.filter(k).length > 0;
   }
-  function P() {
-    return a.filter(Q);
+  function N() {
+    return s.filter(x);
   }
-  function M(t) {
-    return P().filter((n) => n.fn === t.fn);
+  function R(t) {
+    return N().filter((n) => n.fn === t.fn);
   }
-  function y(t) {
-    return t ? t.parallel === 1 / 0 || M(t).length < t.parallel : !1;
+  function A(t) {
+    return t ? t.parallel === 1 / 0 || R(t).length < t.parallel : !1;
   }
   function l() {
-    queueMicrotask(W);
+    queueMicrotask(F);
   }
-  function W() {
-    if (!F()) {
-      k && g(), f("idle");
+  function F() {
+    if (!w()) {
+      p?.(s), f("idle");
       return;
     }
-    k && g();
-    const t = N();
+    p?.(s);
+    const t = V();
     for (const n of t) {
-      if (!b(n, e.QUEUED)) {
-        if (b(n, e.HALTED)) {
-          const o = A(n);
-          if (!o || !y(o))
+      if (!E(n, e.QUEUED)) {
+        if (E(n, e.HALTED)) {
+          const o = d(n);
+          if (!o || !A(o))
             continue;
-          G(o);
+          I(o);
         }
         continue;
       }
-      const r = A(n);
-      y(r) && G(r);
+      const r = d(n);
+      A(r) && I(r);
     }
   }
-  async function G(t) {
+  async function I(t) {
     const { group: n, fn: r, params: o } = t;
     t.state = e.ACTIVE;
     try {
-      const s = U(o) ? o() : o, u = await r(...s, {
+      const a = D(o) ? o() : o, u = await r(...a, {
         abortController: t.abortController
       });
-      d(t), u === !1 && I(n, e.HALTED, { ignoreOptional: !0 });
-    } catch (s) {
-      t.state = e.FAILED, f("error", s), I(n, e.HALTED);
+      m(t), u === !1 && b(n, e.HALTED, { ignoreOptional: !0 });
+    } catch (a) {
+      t.state = e.FAILED, f("error", a), b(n, e.HALTED);
     }
-    V(n) || f("complete", n), l();
+    H(n) || f("complete", n), l();
   }
-  function S(t) {
+  function y(t) {
     t.abortController.signal.aborted || t.abortController.abort();
   }
-  function _(t, n, r) {
-    const { parallel: o = 1 / 0, order: s = 0, params: u = [], isOptional: D = !1 } = r ?? {};
-    !B(t, n) || L(t, n) || (H({
+  function P(t, n, r) {
+    const { parallel: o = 1 / 0, order: a = 0, params: u = [], isOptional: W = !1 } = r ?? {};
+    !C(t, n) || Q(t, n) || (v({
       group: t,
       fn: n,
       params: u,
-      order: s,
+      order: a,
       parallel: o,
-      isOptional: D,
+      isOptional: W,
       state: e.QUEUED,
       abortController: new AbortController()
     }), l());
   }
-  function $(t, n) {
-    const r = w(t, n);
-    r && (S(r), d(r), l());
+  function M(t, n) {
+    const r = O(t, n);
+    r && (y(r), m(r), l());
   }
-  function h(t) {
+  function G(t) {
     if (!t) {
-      for (const n of R())
-        h(n);
+      for (const n of q())
+        G(n);
       return;
     }
-    q(t), O(t), f("abort", t), f("complete", t), l();
+    L(t), B(t), f("abort", t), f("complete", t), l();
   }
   return {
-    on: C,
-    pushTask: _,
-    abortTask: $,
-    abortTasks: h
+    on: U,
+    pushTask: P,
+    abortTask: M,
+    abortTasks: G
   };
 }
 export {
-  tt as createTaskScheduler
+  Y as createTaskScheduler
 };

package/esm/dev/index.js

@@ -0,0 +1,122 @@
+/*!
+* FilePond v5.0.0-beta.21
+* Copyright (c) 2017-2026 Pqina B.V.
+* Released under the MIT License
+* https://filepond.com
+*/
+import { h as y } from "../utils/dom.js";
+import { blobToFile as $ } from "../utils/file.js";
+import { createRandomish as S, randomNumberBetween as b } from "../utils/math.js";
+import { sleep as D } from "../utils/sleep.js";
+const x = 1, u = S(x);
+function M(t, e) {
+  return e ? /text/.test(e) : /\.(txt|md|markdown)$/.test(t);
+}
+function F(t, e) {
+  return e ? /image/.test(e) : /\.(png|jpg|jpeg|webp)$/.test(t);
+}
+async function H(t) {
+  const { name: e = "Untitled", type: i } = t ?? {};
+  return M(e, i) ? await T({
+    ...t,
+    name: e
+  }) ?? null : F(e, i) ? await R({
+    ...t,
+    name: e
+  }) : null;
+}
+function v(t, e, i) {
+  const { width: n, height: a } = t.canvas, d = t.createLinearGradient(
+    n * u(),
+    0,
+    n * u(),
+    a
+  ), p = 3, o = 30;
+  let s = Math.round(b(0, 360 - o, u));
+  for (let c = 0; c < p; c++)
+    s += Math.round(b(o, 90, u)), d.addColorStop(c / (p - 1), `hsl(${s} 90% 50%)`);
+  t.fillStyle = e || d, t.fillRect(0, 0, n, a), t.fillStyle = "rgba(0,0,0,.35)", t.textAlign = "center", t.textBaseline = "middle", t.font = `bold ${n / 16}px sans-serif`, t.fillText(`${i} ${n} × ${a}`, n * 0.5, a * 0.5);
+}
+async function R(t) {
+  const {
+    name: e = "Untitled",
+    width: i = 1280,
+    height: n = 720,
+    quality: a = 0.98,
+    fillStyle: d = void 0,
+    lastModified: p = Date.now()
+  } = t ?? {};
+  let o = "image/png";
+  if (e && !t?.type) {
+    const l = e.split(".").pop();
+    l && /jpeg|png|webp/.test(l) && (o = `image/${e.split(".").pop()}`);
+  }
+  const s = y("canvas", {
+    width: i,
+    height: n
+  }), c = s.getContext("2d");
+  v(c, d, o);
+  const g = await new Promise((l, r) => {
+    try {
+      s.toBlob(
+        (f) => {
+          f ? l(f) : r(new Error("Failed to create blob from canvas"));
+        },
+        o,
+        a
+      );
+    } catch (f) {
+      r(f);
+    }
+  }), m = /\./.test(e) ? e : `${e}.${o.split("/").pop()}`;
+  return $(g, m, { type: o, lastModified: p });
+}
+async function I(t) {
+  const {
+    name: e = "Untitled",
+    width: i = 1280,
+    height: n = 720,
+    fps: a = 10,
+    fillStyle: d = "silver",
+    lastModified: p = Date.now()
+  } = t ?? {}, o = 10, s = "video/webp", c = y("canvas", { width: i, height: n }), g = c.getContext("2d"), m = [], l = new MediaRecorder(c.captureStream(a), {
+    mimeType: "video/webm"
+  });
+  l.ondataavailable = (r) => {
+    r.data.size && m.push(r.data);
+  }, l.start();
+  for (let r = 0; r < o; r++)
+    v(g, d, s), await D(1e3 / a);
+  return await new Promise((r) => {
+    l.onstop = r, setTimeout(() => {
+      l.stop();
+    }, 1e3 / a);
+  }), new File(m, `${e}.${s.split("/").pop()}`, { type: s, lastModified: p });
+}
+async function T(t) {
+  const {
+    name: e = "Untitled",
+    type: i = "text/plain",
+    content: n = "Hello World",
+    lastModified: a = Date.now()
+  } = t ?? {};
+  if (i === "text/plain")
+    return new File([n], e.endsWith(".txt") ? e : `${e}.txt`, {
+      type: i,
+      lastModified: a
+    });
+}
+let h, w;
+function N() {
+  const t = performance.now();
+  h || (h = t), w || (w = t);
+  const e = t - w;
+  return w = t, { ms: t - h, step: e };
+}
+export {
+  T as generateDocument,
+  H as generateFile,
+  R as generateImage,
+  I as generateVideo,
+  N as now
+};