inertia-bootstrap-forms 1.0.56 → 1.0.58

package/dist/index-BNTFmIVu.js

@@ -0,0 +1,604 @@
+var pt = Object.defineProperty;
+var et = (i) => {
+  throw TypeError(i);
+};
+var ct = (i, e, t) => e in i ? pt(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var y = (i, e, t) => ct(i, typeof e != "symbol" ? e + "" : e, t), G = (i, e, t) => e.has(i) || et("Cannot " + t);
+var r = (i, e, t) => (G(i, e, "read from private field"), t ? t.call(i) : e.get(i)), m = (i, e, t) => e.has(i) ? et("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t), c = (i, e, t, s) => (G(i, e, "write to private field"), s ? s.call(i, t) : e.set(i, t), t), g = (i, e, t) => (G(i, e, "access private method"), t);
+import { T as mt } from "./index-Cr0ZhLal.js";
+class K extends Error {
+  constructor(t, s = null) {
+    super("This looks like a network error, the endpoint might be blocked by an internet provider or a firewall.");
+    y(this, "cause");
+    y(this, "isNetworkError");
+    y(this, "request");
+    this.cause = t, this.isNetworkError = !0, this.request = s;
+  }
+}
+var O, M, W, N;
+class ft {
+  constructor(e, t) {
+    m(this, O);
+    m(this, M, !1);
+    m(this, W);
+    m(this, N);
+    c(this, N, e), c(this, W, () => t(e));
+  }
+  progress() {
+    r(this, M) || r(this, N) > 0 && (clearTimeout(r(this, O)), c(this, O, setTimeout(r(this, W), r(this, N))));
+  }
+  done() {
+    r(this, M) || (clearTimeout(r(this, O)), c(this, O, void 0), c(this, M, !0));
+  }
+}
+O = new WeakMap(), M = new WeakMap(), W = new WeakMap(), N = new WeakMap();
+const j = () => {
+};
+function yt(i, e = {}) {
+  const { body: t = null, headers: s = {}, method: o = "GET", onBeforeRequest: a = j, onUploadProgress: n = j, shouldRetry: l = () => !0, onAfterResponse: u = j, onTimeout: h = j, responseType: d, retries: x = 3, signal: f = null, timeout: P = 3e4, withCredentials: b = !1 } = e, B = (F) => 0.3 * 2 ** (F - 1) * 1e3, X = new ft(P, h);
+  function _(F = 0) {
+    return new Promise(async (V, I) => {
+      const p = new XMLHttpRequest(), $ = (S) => {
+        l(p) && F < x ? setTimeout(() => {
+          _(F + 1).then(V, I);
+        }, B(F)) : (X.done(), I(S));
+      };
+      p.open(o, i, !0), p.withCredentials = b, d && (p.responseType = d), p.onload = async () => {
+        try {
+          await u(p, F);
+        } catch (S) {
+          S.request = p, $(S);
+          return;
+        }
+        p.status >= 200 && p.status < 300 ? (X.done(), V(p)) : l(p) && F < x ? setTimeout(() => {
+          _(F + 1).then(V, I);
+        }, B(F)) : (X.done(), I(new K(p.statusText, p)));
+      }, p.onerror = () => $(new K(p.statusText, p)), p.upload.onprogress = (S) => {
+        X.progress(), n(S);
+      }, s && Object.keys(s).forEach((S) => {
+        p.setRequestHeader(S, s[S]);
+      });
+      function tt() {
+        p.abort(), I(new DOMException("Aborted", "AbortError"));
+      }
+      if (f == null || f.addEventListener("abort", tt), f != null && f.aborted) {
+        tt();
+        return;
+      }
+      await a(p, F), p.send(t);
+    });
+  }
+  return _();
+}
+const wt = (i) => "error" in i && !!i.error, gt = (i) => i.progress.uploadComplete;
+function bt(i) {
+  return i.filter((e) => !wt(e) && !gt(e));
+}
+function Ft(i) {
+  return i.filter((e) => {
+    var t;
+    return !((t = e.progress) != null && t.uploadStarted) || !e.isRestored;
+  });
+}
+function st(i, e) {
+  return i === !0 ? Object.keys(e) : Array.isArray(i) ? i : [];
+}
+function Et(i) {
+  return i ? i.readyState === 4 && i.status === 0 : !1;
+}
+function Tt(i) {
+  return new Error("Cancelled", { cause: i });
+}
+function it(i) {
+  var e;
+  if (i != null) {
+    const t = () => this.abort(i.reason);
+    i.addEventListener("abort", t, { once: !0 });
+    const s = () => {
+      i.removeEventListener("abort", t);
+    };
+    (e = this.then) == null || e.call(this, s, s);
+  }
+  return this;
+}
+var U, E, v, L, T, C, A, w, Z, H, rt, nt, at, Q, k;
+class Rt {
+  constructor(e) {
+    m(this, w);
+    m(this, U, 0);
+    m(this, E, []);
+    m(this, v, !1);
+    m(this, L);
+    m(this, T, 1);
+    m(this, C);
+    m(this, A);
+    y(this, "limit");
+    m(this, Q, () => this.resume());
+    m(this, k, () => {
+      if (r(this, v)) {
+        c(this, A, setTimeout(r(this, k), 0));
+        return;
+      }
+      c(this, T, this.limit), this.limit = Math.ceil((r(this, C) + r(this, T)) / 2);
+      for (let e = r(this, T); e <= this.limit; e++)
+        g(this, w, H).call(this);
+      r(this, C) - r(this, T) > 3 ? c(this, A, setTimeout(r(this, k), 2e3)) : c(this, T, Math.floor(r(this, T) / 2));
+    });
+    typeof e != "number" || e === 0 ? this.limit = 1 / 0 : this.limit = e;
+  }
+  run(e, t) {
+    return !r(this, v) && r(this, U) < this.limit ? g(this, w, Z).call(this, e) : g(this, w, nt).call(this, e, t);
+  }
+  wrapSyncFunction(e, t) {
+    return (...s) => {
+      const o = this.run(() => (e(...s), queueMicrotask(() => o.done()), () => {
+      }), t);
+      return {
+        abortOn: it,
+        abort() {
+          o.abort();
+        }
+      };
+    };
+  }
+  wrapPromiseFunction(e, t) {
+    return (...s) => {
+      let o;
+      const a = new Promise((n, l) => {
+        o = this.run(() => {
+          let u, h;
+          try {
+            h = Promise.resolve(e(...s));
+          } catch (d) {
+            h = Promise.reject(d);
+          }
+          return h.then((d) => {
+            u ? l(u) : (o.done(), n(d));
+          }, (d) => {
+            u ? l(u) : (o.done(), l(d));
+          }), (d) => {
+            u = Tt(d);
+          };
+        }, t);
+      });
+      return a.abort = (n) => {
+        o.abort(n);
+      }, a.abortOn = it, a;
+    };
+  }
+  resume() {
+    c(this, v, !1), clearTimeout(r(this, L));
+    for (let e = 0; e < this.limit; e++)
+      g(this, w, H).call(this);
+  }
+  /**
+   * Freezes the queue for a while or indefinitely.
+   *
+   * @param {number | null } [duration] Duration for the pause to happen, in milliseconds.
+   *                                    If omitted, the queue won't resume automatically.
+   */
+  pause(e = null) {
+    c(this, v, !0), clearTimeout(r(this, L)), e != null && c(this, L, setTimeout(r(this, Q), e));
+  }
+  /**
+   * Pauses the queue for a duration, and lower the limit of concurrent requests
+   * when the queue resumes. When the queue resumes, it tries to progressively
+   * increase the limit in `this.#increaseLimit` until another call is made to
+   * `this.rateLimit`.
+   * Call this function when using the RateLimitedQueue for network requests and
+   * the remote server responds with 429 HTTP code.
+   *
+   * @param {number} duration in milliseconds.
+   */
+  rateLimit(e) {
+    clearTimeout(r(this, A)), this.pause(e), this.limit > 1 && Number.isFinite(this.limit) && (c(this, C, this.limit - 1), this.limit = r(this, T), c(this, A, setTimeout(r(this, k), e)));
+  }
+  get isPaused() {
+    return r(this, v);
+  }
+}
+U = new WeakMap(), E = new WeakMap(), v = new WeakMap(), L = new WeakMap(), T = new WeakMap(), C = new WeakMap(), A = new WeakMap(), w = new WeakSet(), Z = function(e) {
+  c(this, U, r(this, U) + 1);
+  let t = !1, s;
+  try {
+    s = e();
+  } catch (o) {
+    throw c(this, U, r(this, U) - 1), o;
+  }
+  return {
+    abort: (o) => {
+      t || (t = !0, c(this, U, r(this, U) - 1), s == null || s(o), g(this, w, H).call(this));
+    },
+    done: () => {
+      t || (t = !0, c(this, U, r(this, U) - 1), g(this, w, H).call(this));
+    }
+  };
+}, H = function() {
+  queueMicrotask(() => g(this, w, rt).call(this));
+}, rt = function() {
+  if (r(this, v) || r(this, U) >= this.limit || r(this, E).length === 0)
+    return;
+  const e = r(this, E).shift();
+  if (e == null)
+    throw new Error("Invariant violation: next is null");
+  const t = g(this, w, Z).call(this, e.fn);
+  e.abort = t.abort, e.done = t.done;
+}, nt = function(e, t) {
+  const s = {
+    fn: e,
+    priority: (t == null ? void 0 : t.priority) || 0,
+    abort: () => {
+      g(this, w, at).call(this, s);
+    },
+    done: () => {
+      throw new Error("Cannot mark a queued request as done: this indicates a bug");
+    }
+  }, o = r(this, E).findIndex((a) => s.priority > a.priority);
+  return o === -1 ? r(this, E).push(s) : r(this, E).splice(o, 0, s), s;
+}, at = function(e) {
+  const t = r(this, E).indexOf(e);
+  t !== -1 && r(this, E).splice(t, 1);
+}, Q = new WeakMap(), k = new WeakMap();
+const Y = Symbol("__queue");
+class qt {
+  constructor(e, t) {
+    y(this, "uppy");
+    y(this, "opts");
+    y(this, "id");
+    y(this, "defaultLocale");
+    y(this, "i18n");
+    y(this, "i18nArray");
+    y(this, "type");
+    y(this, "VERSION");
+    this.uppy = e, this.opts = t ?? {};
+  }
+  getPluginState() {
+    const { plugins: e } = this.uppy.getState();
+    return (e == null ? void 0 : e[this.id]) || {};
+  }
+  setPluginState(e) {
+    const { plugins: t } = this.uppy.getState();
+    this.uppy.setState({
+      plugins: {
+        ...t,
+        [this.id]: {
+          ...t[this.id],
+          ...e
+        }
+      }
+    });
+  }
+  setOptions(e) {
+    this.opts = { ...this.opts, ...e }, this.setPluginState(void 0), this.i18nInit();
+  }
+  i18nInit() {
+    const e = new mt([
+      this.defaultLocale,
+      this.uppy.locale,
+      this.opts.locale
+    ]);
+    this.i18n = e.translate.bind(e), this.i18nArray = e.translateArray.bind(e), this.setPluginState(void 0);
+  }
+  /**
+   * Extendable methods
+   * ==================
+   * These methods are here to serve as an overview of the extendable methods as well as
+   * making them not conditional in use, such as `if (this.afterUpdate)`.
+   */
+  addTarget(e) {
+    throw new Error("Extend the addTarget method to add your plugin to another plugin's target");
+  }
+  install() {
+  }
+  uninstall() {
+  }
+  update(e) {
+  }
+  // Called after every state update, after everything's mounted. Debounced.
+  afterUpdate() {
+  }
+}
+var R, z;
+class St {
+  constructor(e) {
+    m(this, R);
+    m(this, z, []);
+    c(this, R, e);
+  }
+  on(e, t) {
+    return r(this, z).push([e, t]), r(this, R).on(e, t);
+  }
+  remove() {
+    for (const [e, t] of r(this, z).splice(0))
+      r(this, R).off(e, t);
+  }
+  onFilePause(e, t) {
+    this.on("upload-pause", (s, o) => {
+      e === (s == null ? void 0 : s.id) && t(o);
+    });
+  }
+  onFileRemove(e, t) {
+    this.on("file-removed", (s) => {
+      e === s.id && t(s.id);
+    });
+  }
+  onPause(e, t) {
+    this.on("upload-pause", (s, o) => {
+      e === (s == null ? void 0 : s.id) && t(o);
+    });
+  }
+  onRetry(e, t) {
+    this.on("upload-retry", (s) => {
+      e === (s == null ? void 0 : s.id) && t();
+    });
+  }
+  onRetryAll(e, t) {
+    this.on("retry-all", () => {
+      r(this, R).getFile(e) && t();
+    });
+  }
+  onPauseAll(e, t) {
+    this.on("pause-all", () => {
+      r(this, R).getFile(e) && t();
+    });
+  }
+  onCancelAll(e, t) {
+    this.on("cancel-all", (...s) => {
+      r(this, R).getFile(e) && t(...s);
+    });
+  }
+  onResumeAll(e, t) {
+    this.on("resume-all", () => {
+      r(this, R).getFile(e) && t();
+    });
+  }
+}
+R = new WeakMap(), z = new WeakMap();
+const Ut = "5.1.1", vt = {
+  version: Ut
+}, Pt = {
+  strings: {
+    // Shown in the Informer if an upload is being canceled because it stalled for too long.
+    uploadStalled: "Upload has not made any progress for %{seconds} seconds. You may want to retry it."
+  }
+};
+function Ot(i, e) {
+  let t = e;
+  return t || (t = new Error("Upload error")), typeof t == "string" && (t = new Error(t)), t instanceof Error || (t = Object.assign(new Error("Upload error"), { data: t })), Et(i) ? (t = new K(t, i), t) : (t.request = i, t);
+}
+function ot(i) {
+  return i.data.slice(0, i.data.size, i.meta.type);
+}
+const At = {
+  formData: !0,
+  fieldName: "file",
+  method: "post",
+  allowedMetaFields: !0,
+  bundle: !1,
+  headers: {},
+  timeout: 30 * 1e3,
+  limit: 5,
+  withCredentials: !1,
+  responseType: ""
+};
+var D, q, lt, ut, ht, dt, J;
+class xt extends qt {
+  constructor(t, s) {
+    super(t, {
+      ...At,
+      fieldName: s.bundle ? "files[]" : "file",
+      ...s
+    });
+    m(this, q);
+    m(this, D);
+    y(this, "requests");
+    y(this, "uploaderEvents");
+    m(this, J, async (t) => {
+      if (t.length === 0) {
+        this.uppy.log("[XHRUpload] No files to upload!");
+        return;
+      }
+      this.opts.limit === 0 && !this.opts[Y] && this.uppy.log("[XHRUpload] When uploading multiple files at once, consider setting the `limit` option (to `10` for example), to limit the number of concurrent uploads, which helps prevent memory and network issues: https://uppy.io/docs/xhr-upload/#limit-0", "warning"), this.uppy.log("[XHRUpload] Uploading...");
+      const s = this.uppy.getFilesByIds(t), o = bt(s), a = Ft(o);
+      if (this.uppy.emit("upload-start", a), this.opts.bundle) {
+        if (o.some((l) => l.isRemote))
+          throw new Error("Can’t upload remote files when the `bundle: true` option is set");
+        if (typeof this.opts.headers == "function")
+          throw new TypeError("`headers` may not be a function when the `bundle: true` option is set");
+        await g(this, q, ut).call(this, o);
+      } else
+        await g(this, q, dt).call(this, o);
+    });
+    if (this.type = "uploader", this.id = this.opts.id || "XHRUpload", this.defaultLocale = Pt, this.i18nInit(), Y in this.opts ? this.requests = this.opts[Y] : this.requests = new Rt(this.opts.limit), this.opts.bundle && !this.opts.formData)
+      throw new Error("`opts.formData` must be true when `opts.bundle` is enabled.");
+    if (this.opts.bundle && typeof this.opts.headers == "function")
+      throw new Error("`opts.headers` can not be a function when the `bundle: true` option is set.");
+    if ((s == null ? void 0 : s.allowedMetaFields) === void 0 && "metaFields" in this.opts)
+      throw new Error("The `metaFields` option has been renamed to `allowedMetaFields`.");
+    this.uploaderEvents = /* @__PURE__ */ Object.create(null), c(this, D, (o) => async (a, n) => {
+      var l, u;
+      try {
+        const h = await yt(a, {
+          ...n,
+          onBeforeRequest: (f, P) => {
+            var b, B;
+            return (B = (b = this.opts).onBeforeRequest) == null ? void 0 : B.call(b, f, P, o);
+          },
+          shouldRetry: this.opts.shouldRetry,
+          onAfterResponse: this.opts.onAfterResponse,
+          onTimeout: (f) => {
+            const P = Math.ceil(f / 1e3), b = new Error(this.i18n("uploadStalled", { seconds: P }));
+            this.uppy.emit("upload-stalled", b, o);
+          },
+          onUploadProgress: (f) => {
+            if (f.lengthComputable)
+              for (const { id: P } of o) {
+                const b = this.uppy.getFile(P);
+                b != null && this.uppy.emit("upload-progress", b, {
+                  uploadStarted: b.progress.uploadStarted ?? 0,
+                  bytesUploaded: f.loaded / f.total * b.size,
+                  bytesTotal: b.size
+                });
+              }
+          }
+        });
+        let d = await ((u = (l = this.opts).getResponseData) == null ? void 0 : u.call(l, h));
+        if (h.responseType === "json")
+          d ?? (d = h.response);
+        else
+          try {
+            d ?? (d = JSON.parse(h.responseText));
+          } catch (f) {
+            throw new Error("@uppy/xhr-upload expects a JSON response (with a `url` property). To parse non-JSON responses, use `getResponseData` to turn your response into JSON.", { cause: f });
+          }
+        const x = typeof (d == null ? void 0 : d.url) == "string" ? d.url : void 0;
+        for (const { id: f } of o)
+          this.uppy.emit("upload-success", this.uppy.getFile(f), {
+            status: h.status,
+            body: d,
+            uploadURL: x
+          });
+        return h;
+      } catch (h) {
+        if (h.name === "AbortError")
+          return;
+        const d = h.request;
+        for (const x of o)
+          this.uppy.emit("upload-error", this.uppy.getFile(x.id), Ot(d, h), d);
+        throw h;
+      }
+    });
+  }
+  getOptions(t) {
+    const s = this.uppy.getState().xhrUpload, { headers: o } = this.opts, a = {
+      ...this.opts,
+      ...s || {},
+      ...t.xhrUpload || {},
+      headers: {}
+    };
+    return typeof o == "function" ? a.headers = o(t) : Object.assign(a.headers, this.opts.headers), s && Object.assign(a.headers, s.headers), t.xhrUpload && Object.assign(a.headers, t.xhrUpload.headers), a;
+  }
+  addMetadata(t, s, o) {
+    st(o.allowedMetaFields, s).forEach((n) => {
+      const l = s[n];
+      Array.isArray(l) ? l.forEach((u) => t.append(n, u)) : t.append(n, l);
+    });
+  }
+  createFormDataUpload(t, s) {
+    const o = new FormData();
+    this.addMetadata(o, t.meta, s);
+    const a = ot(t);
+    return t.name ? o.append(s.fieldName, a, t.meta.name) : o.append(s.fieldName, a), o;
+  }
+  createBundledUpload(t, s) {
+    const o = new FormData(), { meta: a } = this.uppy.getState();
+    return this.addMetadata(o, a, s), t.forEach((n) => {
+      const l = this.getOptions(n), u = ot(n);
+      n.name ? o.append(l.fieldName, u, n.name) : o.append(l.fieldName, u);
+    }), o;
+  }
+  install() {
+    if (this.opts.bundle) {
+      const { capabilities: t } = this.uppy.getState();
+      this.uppy.setState({
+        capabilities: {
+          ...t,
+          individualCancellation: !1
+        }
+      });
+    }
+    this.uppy.addUploader(r(this, J));
+  }
+  uninstall() {
+    if (this.opts.bundle) {
+      const { capabilities: t } = this.uppy.getState();
+      this.uppy.setState({
+        capabilities: {
+          ...t,
+          individualCancellation: !0
+        }
+      });
+    }
+    this.uppy.removeUploader(r(this, J));
+  }
+}
+D = new WeakMap(), q = new WeakSet(), lt = async function(t) {
+  const s = new St(this.uppy), o = new AbortController(), a = this.requests.wrapPromiseFunction(async () => {
+    const n = this.getOptions(t), l = r(this, D).call(this, [t]), u = n.formData ? this.createFormDataUpload(t, n) : t.data, h = typeof n.endpoint == "string" ? n.endpoint : await n.endpoint(t);
+    return l(h, {
+      ...n,
+      body: u,
+      signal: o.signal
+    });
+  });
+  s.onFileRemove(t.id, () => o.abort()), s.onCancelAll(t.id, () => {
+    o.abort();
+  });
+  try {
+    await a();
+  } catch (n) {
+    if (n.message !== "Cancelled")
+      throw n;
+  } finally {
+    s.remove();
+  }
+}, ut = async function(t) {
+  const s = new AbortController(), o = this.requests.wrapPromiseFunction(async () => {
+    const n = this.uppy.getState().xhrUpload ?? {}, l = r(this, D).call(this, t), u = this.createBundledUpload(t, {
+      ...this.opts,
+      ...n
+    }), h = typeof this.opts.endpoint == "string" ? this.opts.endpoint : await this.opts.endpoint(t);
+    return l(h, {
+      // headers can't be a function with bundle: true
+      ...this.opts,
+      body: u,
+      signal: s.signal
+    });
+  });
+  function a() {
+    s.abort();
+  }
+  this.uppy.once("cancel-all", a);
+  try {
+    await o();
+  } catch (n) {
+    if (n.message !== "Cancelled")
+      throw n;
+  } finally {
+    this.uppy.off("cancel-all", a);
+  }
+}, ht = function(t) {
+  var a;
+  const s = this.getOptions(t), o = st(s.allowedMetaFields, t.meta);
+  return {
+    ...(a = t.remote) == null ? void 0 : a.body,
+    protocol: "multipart",
+    endpoint: s.endpoint,
+    size: t.data.size,
+    fieldname: s.fieldName,
+    metadata: Object.fromEntries(o.map((n) => [n, t.meta[n]])),
+    httpMethod: s.method,
+    useFormData: s.formData,
+    headers: s.headers
+  };
+}, dt = async function(t) {
+  await Promise.allSettled(t.map((s) => {
+    if (s.isRemote) {
+      const o = () => this.requests, a = new AbortController(), n = (u) => {
+        u.id === s.id && a.abort();
+      };
+      this.uppy.on("file-removed", n);
+      const l = this.uppy.getRequestClientForFile(s).uploadRemoteFile(s, g(this, q, ht).call(this, s), {
+        signal: a.signal,
+        getQueue: o
+      });
+      return this.requests.wrapSyncFunction(() => {
+        this.uppy.off("file-removed", n);
+      }, { priority: -1 })(), l;
+    }
+    return g(this, q, lt).call(this, s);
+  }));
+}, J = new WeakMap(), y(xt, "VERSION", vt.version);
+export {
+  xt as default
+};