@feedmepos/mf-payment 1.6.16-dev → 1.6.17-dev

package/dist/AdminRestaurantSelector.vue_vue_type_script_setup_true_lang-B3adh27R.js

@@ -0,0 +1,890 @@
+var Me = (t) => {
+  throw TypeError(t);
+};
+var ye = (t, e, s) => e.has(t) || Me("Cannot " + s);
+var n = (t, e, s) => (ye(t, e, "read from private field"), s ? s.call(t) : e.get(t)), v = (t, e, s) => e.has(t) ? Me("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), u = (t, e, s, i) => (ye(t, e, "write to private field"), i ? i.call(t, s) : e.set(t, s), s), b = (t, e, s) => (ye(t, e, "access private method"), s);
+import { isRef as tt, unref as me, hasInjectionContext as nt, inject as it, getCurrentScope as rt, computed as T, shallowReactive as ot, reactive as at, watch as Z, onScopeDispose as lt, shallowReadonly as ut, readonly as ct, toRefs as ht, defineComponent as dt, useModel as ft, toRef as pt, ref as Qe, resolveComponent as Y, openBlock as A, createBlock as oe, withCtx as ge, createVNode as Oe, createElementVNode as pe, createElementBlock as Ue, Fragment as vt, renderList as mt, toDisplayString as Ne, createCommentVNode as bt, withModifiers as yt, mergeModels as gt } from "vue";
+import { r as we } from "./index-Tu0z1D-j.js";
+import { useI18n as Ot } from "@feedmepos/mf-common";
+var xe = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(t) {
+    return this.listeners.add(t), this.onSubscribe(), () => {
+      this.listeners.delete(t), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, z, D, G, Ze, wt = (Ze = class extends xe {
+  constructor() {
+    super();
+    v(this, z);
+    v(this, D);
+    v(this, G);
+    u(this, G, (e) => {
+      if (typeof window < "u" && window.addEventListener) {
+        const s = () => e();
+        return window.addEventListener("visibilitychange", s, !1), () => {
+          window.removeEventListener("visibilitychange", s);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    n(this, D) || this.setEventListener(n(this, G));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = n(this, D)) == null || e.call(this), u(this, D, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    u(this, G, e), (s = n(this, D)) == null || s.call(this), u(this, D, e((i) => {
+      typeof i == "boolean" ? this.setFocused(i) : this.onFocus();
+    }));
+  }
+  setFocused(e) {
+    n(this, z) !== e && (u(this, z, e), this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((s) => {
+      s(e);
+    });
+  }
+  isFocused() {
+    var e;
+    return typeof n(this, z) == "boolean" ? n(this, z) : ((e = globalThis.document) == null ? void 0 : e.visibilityState) !== "hidden";
+  }
+}, z = new WeakMap(), D = new WeakMap(), G = new WeakMap(), Ze), St = new wt(), Rt = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (t, e) => setTimeout(t, e),
+  clearTimeout: (t) => clearTimeout(t),
+  setInterval: (t, e) => setInterval(t, e),
+  clearInterval: (t) => clearInterval(t)
+}, L, B, Ge, Et = (Ge = class {
+  constructor() {
+    // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+    // type at app boot; and if we leave that type, then any new timer provider
+    // would need to support the default provider's concrete timer ID, which is
+    // infeasible across environments.
+    //
+    // We settle for type safety for the TimeoutProvider type, and accept that
+    // this class is unsafe internally to allow for extension.
+    v(this, L, Rt);
+    v(this, B, !1);
+  }
+  setTimeoutProvider(t) {
+    process.env.NODE_ENV !== "production" && n(this, B) && t !== n(this, L) && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: n(this, L), provider: t }
+    ), u(this, L, t), process.env.NODE_ENV !== "production" && u(this, B, !1);
+  }
+  setTimeout(t, e) {
+    return process.env.NODE_ENV !== "production" && u(this, B, !0), n(this, L).setTimeout(t, e);
+  }
+  clearTimeout(t) {
+    n(this, L).clearTimeout(t);
+  }
+  setInterval(t, e) {
+    return process.env.NODE_ENV !== "production" && u(this, B, !0), n(this, L).setInterval(t, e);
+  }
+  clearInterval(t) {
+    n(this, L).clearInterval(t);
+  }
+}, L = new WeakMap(), B = new WeakMap(), Ge), ve = new Et();
+function Ft(t) {
+  setTimeout(t, 0);
+}
+var It = typeof window > "u" || "Deno" in globalThis;
+function Ct() {
+}
+function Ve(t) {
+  return typeof t == "number" && t >= 0 && t !== 1 / 0;
+}
+function _t(t, e) {
+  return Math.max(t + (e || 0) - Date.now(), 0);
+}
+function le(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function _(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+var jt = Object.prototype.hasOwnProperty;
+function Re(t, e, s = 0) {
+  if (t === e)
+    return t;
+  if (s > 500) return e;
+  const i = Ae(t) && Ae(e);
+  if (!i && !(ze(t) && ze(e))) return e;
+  const o = (i ? t : Object.keys(t)).length, h = i ? e : Object.keys(e), l = h.length, m = i ? new Array(l) : {};
+  let I = 0;
+  for (let F = 0; F < l; F++) {
+    const f = i ? F : h[F], y = t[f], a = e[f];
+    if (y === a) {
+      m[f] = y, (i ? F < o : jt.call(t, f)) && I++;
+      continue;
+    }
+    if (y === null || a === null || typeof y != "object" || typeof a != "object") {
+      m[f] = a;
+      continue;
+    }
+    const g = Re(y, a, s + 1);
+    m[f] = g, g === y && I++;
+  }
+  return o === l && I === o ? t : m;
+}
+function Ee(t, e) {
+  if (!e || Object.keys(t).length !== Object.keys(e).length)
+    return !1;
+  for (const s in t)
+    if (t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function Ae(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function ze(t) {
+  if (!Be(t))
+    return !1;
+  const e = t.constructor;
+  if (e === void 0)
+    return !0;
+  const s = e.prototype;
+  return !(!Be(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(t) !== Object.prototype);
+}
+function Be(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function qe(t, e, s) {
+  if (typeof s.structuralSharing == "function")
+    return s.structuralSharing(t, e);
+  if (s.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return Re(t, e);
+      } catch (i) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${s.queryHash}]: ${i}`
+        ), i;
+      }
+    return Re(t, e);
+  }
+  return e;
+}
+function Tt(t) {
+  return t;
+}
+function $e(t, e) {
+  return typeof t == "function" ? t(...e) : !!t;
+}
+var Ke = /* @__PURE__ */ (() => {
+  let t = () => It;
+  return {
+    /**
+     * Returns whether the current runtime should be treated as a server environment.
+     */
+    isServer() {
+      return t();
+    },
+    /**
+     * Overrides the server check globally.
+     */
+    setIsServer(e) {
+      t = e;
+    }
+  };
+})();
+function We() {
+  let t, e;
+  const s = new Promise((r, o) => {
+    t = r, e = o;
+  });
+  s.status = "pending", s.catch(() => {
+  });
+  function i(r) {
+    Object.assign(s, r), delete s.resolve, delete s.reject;
+  }
+  return s.resolve = (r) => {
+    i({
+      status: "fulfilled",
+      value: r
+    }), t(r);
+  }, s.reject = (r) => {
+    i({
+      status: "rejected",
+      reason: r
+    }), e(r);
+  }, s;
+}
+var Lt = Ft;
+function kt() {
+  let t = [], e = 0, s = (l) => {
+    l();
+  }, i = (l) => {
+    l();
+  }, r = Lt;
+  const o = (l) => {
+    e ? t.push(l) : r(() => {
+      s(l);
+    });
+  }, h = () => {
+    const l = t;
+    t = [], l.length && r(() => {
+      i(() => {
+        l.forEach((m) => {
+          s(m);
+        });
+      });
+    });
+  };
+  return {
+    batch: (l) => {
+      let m;
+      e++;
+      try {
+        m = l();
+      } finally {
+        e--, e || h();
+      }
+      return m;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (l) => (...m) => {
+      o(() => {
+        l(...m);
+      });
+    },
+    schedule: o,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (l) => {
+      s = l;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (l) => {
+      i = l;
+    },
+    setScheduler: (l) => {
+      r = l;
+    }
+  };
+}
+var Pt = kt(), X, M, ee, Xe, xt = (Xe = class extends xe {
+  constructor() {
+    super();
+    v(this, X, !0);
+    v(this, M);
+    v(this, ee);
+    u(this, ee, (e) => {
+      if (typeof window < "u" && window.addEventListener) {
+        const s = () => e(!0), i = () => e(!1);
+        return window.addEventListener("online", s, !1), window.addEventListener("offline", i, !1), () => {
+          window.removeEventListener("online", s), window.removeEventListener("offline", i);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    n(this, M) || this.setEventListener(n(this, ee));
+  }
+  onUnsubscribe() {
+    var e;
+    this.hasListeners() || ((e = n(this, M)) == null || e.call(this), u(this, M, void 0));
+  }
+  setEventListener(e) {
+    var s;
+    u(this, ee, e), (s = n(this, M)) == null || s.call(this), u(this, M, e(this.setOnline.bind(this)));
+  }
+  setOnline(e) {
+    n(this, X) !== e && (u(this, X, e), this.listeners.forEach((i) => {
+      i(e);
+    }));
+  }
+  isOnline() {
+    return n(this, X);
+  }
+}, X = new WeakMap(), M = new WeakMap(), ee = new WeakMap(), Xe), Dt = new xt();
+function Mt(t) {
+  return (t ?? "online") === "online" ? Dt.isOnline() : !0;
+}
+function Qt(t, e) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: Mt(e.networkMode) ? "fetching" : "paused",
+    ...t === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+var E, c, ue, S, q, te, P, Q, ce, se, ne, $, K, U, ie, d, ae, Fe, Ie, Ce, _e, je, Te, Le, st, et, Ut = (et = class extends xe {
+  constructor(e, s) {
+    super();
+    v(this, d);
+    v(this, E);
+    v(this, c);
+    v(this, ue);
+    v(this, S);
+    v(this, q);
+    v(this, te);
+    v(this, P);
+    v(this, Q);
+    v(this, ce);
+    v(this, se);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    v(this, ne);
+    v(this, $);
+    v(this, K);
+    v(this, U);
+    v(this, ie, /* @__PURE__ */ new Set());
+    this.options = s, u(this, E, e), u(this, Q, null), u(this, P, We()), this.bindMethods(), this.setOptions(s);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (n(this, c).addObserver(this), He(n(this, c), this.options) ? b(this, d, ae).call(this) : this.updateResult(), b(this, d, _e).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return ke(
+      n(this, c),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return ke(
+      n(this, c),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), b(this, d, je).call(this), b(this, d, Te).call(this), n(this, c).removeObserver(this);
+  }
+  setOptions(e) {
+    const s = this.options, i = n(this, c);
+    if (this.options = n(this, E).defaultQueryOptions(e), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof _(this.options.enabled, n(this, c)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    b(this, d, Le).call(this), n(this, c).setOptions(this.options), s._defaulted && !Ee(this.options, s) && n(this, E).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: n(this, c),
+      observer: this
+    });
+    const r = this.hasListeners();
+    r && Je(
+      n(this, c),
+      i,
+      this.options,
+      s
+    ) && b(this, d, ae).call(this), this.updateResult(), r && (n(this, c) !== i || _(this.options.enabled, n(this, c)) !== _(s.enabled, n(this, c)) || le(this.options.staleTime, n(this, c)) !== le(s.staleTime, n(this, c))) && b(this, d, Fe).call(this);
+    const o = b(this, d, Ie).call(this);
+    r && (n(this, c) !== i || _(this.options.enabled, n(this, c)) !== _(s.enabled, n(this, c)) || o !== n(this, U)) && b(this, d, Ce).call(this, o);
+  }
+  getOptimisticResult(e) {
+    const s = n(this, E).getQueryCache().build(n(this, E), e), i = this.createResult(s, e);
+    return Vt(this, i) && (u(this, S, i), u(this, te, this.options), u(this, q, n(this, c).state)), i;
+  }
+  getCurrentResult() {
+    return n(this, S);
+  }
+  trackResult(e, s) {
+    return new Proxy(e, {
+      get: (i, r) => (this.trackProp(r), s == null || s(r), r === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && n(this, P).status === "pending" && n(this, P).reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      )), Reflect.get(i, r))
+    });
+  }
+  trackProp(e) {
+    n(this, ie).add(e);
+  }
+  getCurrentQuery() {
+    return n(this, c);
+  }
+  refetch({ ...e } = {}) {
+    return this.fetch({
+      ...e
+    });
+  }
+  fetchOptimistic(e) {
+    const s = n(this, E).defaultQueryOptions(e), i = n(this, E).getQueryCache().build(n(this, E), s);
+    return i.fetch().then(() => this.createResult(i, s));
+  }
+  fetch(e) {
+    return b(this, d, ae).call(this, {
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), n(this, S)));
+  }
+  createResult(e, s) {
+    var de;
+    const i = n(this, c), r = this.options, o = n(this, S), h = n(this, q), l = n(this, te), I = e !== i ? e.state : n(this, ue), { state: F } = e;
+    let f = { ...F }, y = !1, a;
+    if (s._optimisticResults) {
+      const R = this.hasListeners(), V = !R && He(e, s), H = R && Je(e, i, s, r);
+      (V || H) && (f = {
+        ...f,
+        ...Qt(F.data, e.options)
+      }), s._optimisticResults === "isRestoring" && (f.fetchStatus = "idle");
+    }
+    let { error: g, errorUpdatedAt: j, status: O } = f;
+    a = f.data;
+    let x = !1;
+    if (s.placeholderData !== void 0 && a === void 0 && O === "pending") {
+      let R;
+      o != null && o.isPlaceholderData && s.placeholderData === (l == null ? void 0 : l.placeholderData) ? (R = o.data, x = !0) : R = typeof s.placeholderData == "function" ? s.placeholderData(
+        (de = n(this, ne)) == null ? void 0 : de.state.data,
+        n(this, ne)
+      ) : s.placeholderData, R !== void 0 && (O = "success", a = qe(
+        o == null ? void 0 : o.data,
+        R,
+        s
+      ), y = !0);
+    }
+    if (s.select && a !== void 0 && !x)
+      if (o && a === (h == null ? void 0 : h.data) && s.select === n(this, ce))
+        a = n(this, se);
+      else
+        try {
+          u(this, ce, s.select), a = s.select(a), a = qe(o == null ? void 0 : o.data, a, s), u(this, se, a), u(this, Q, null);
+        } catch (R) {
+          u(this, Q, R);
+        }
+    n(this, Q) && (g = n(this, Q), a = n(this, se), j = Date.now(), O = "error");
+    const k = f.fetchStatus === "fetching", W = O === "pending", re = O === "error", he = W && k, p = a !== void 0, C = {
+      status: O,
+      fetchStatus: f.fetchStatus,
+      isPending: W,
+      isSuccess: O === "success",
+      isError: re,
+      isInitialLoading: he,
+      isLoading: he,
+      data: a,
+      dataUpdatedAt: f.dataUpdatedAt,
+      error: g,
+      errorUpdatedAt: j,
+      failureCount: f.fetchFailureCount,
+      failureReason: f.fetchFailureReason,
+      errorUpdateCount: f.errorUpdateCount,
+      isFetched: e.isFetched(),
+      isFetchedAfterMount: f.dataUpdateCount > I.dataUpdateCount || f.errorUpdateCount > I.errorUpdateCount,
+      isFetching: k,
+      isRefetching: k && !W,
+      isLoadingError: re && !p,
+      isPaused: f.fetchStatus === "paused",
+      isPlaceholderData: y,
+      isRefetchError: re && p,
+      isStale: De(e, s),
+      refetch: this.refetch,
+      promise: n(this, P),
+      isEnabled: _(s.enabled, e) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const R = C.data !== void 0, V = C.status === "error" && !R, H = (J) => {
+        V ? J.reject(C.error) : R && J.resolve(C.data);
+      }, fe = () => {
+        const J = u(this, P, C.promise = We());
+        H(J);
+      }, w = n(this, P);
+      switch (w.status) {
+        case "pending":
+          e.queryHash === i.queryHash && H(w);
+          break;
+        case "fulfilled":
+          (V || C.data !== w.value) && fe();
+          break;
+        case "rejected":
+          (!V || C.error !== w.reason) && fe();
+          break;
+      }
+    }
+    return C;
+  }
+  updateResult() {
+    const e = n(this, S), s = this.createResult(n(this, c), this.options);
+    if (u(this, q, n(this, c).state), u(this, te, this.options), n(this, q).data !== void 0 && u(this, ne, n(this, c)), Ee(s, e))
+      return;
+    u(this, S, s);
+    const i = () => {
+      if (!e)
+        return !0;
+      const { notifyOnChangeProps: r } = this.options, o = typeof r == "function" ? r() : r;
+      if (o === "all" || !o && !n(this, ie).size)
+        return !0;
+      const h = new Set(
+        o ?? n(this, ie)
+      );
+      return this.options.throwOnError && h.add("error"), Object.keys(n(this, S)).some((l) => {
+        const m = l;
+        return n(this, S)[m] !== e[m] && h.has(m);
+      });
+    };
+    b(this, d, st).call(this, { listeners: i() });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && b(this, d, _e).call(this);
+  }
+}, E = new WeakMap(), c = new WeakMap(), ue = new WeakMap(), S = new WeakMap(), q = new WeakMap(), te = new WeakMap(), P = new WeakMap(), Q = new WeakMap(), ce = new WeakMap(), se = new WeakMap(), ne = new WeakMap(), $ = new WeakMap(), K = new WeakMap(), U = new WeakMap(), ie = new WeakMap(), d = new WeakSet(), ae = function(e) {
+  b(this, d, Le).call(this);
+  let s = n(this, c).fetch(
+    this.options,
+    e
+  );
+  return e != null && e.throwOnError || (s = s.catch(Ct)), s;
+}, Fe = function() {
+  b(this, d, je).call(this);
+  const e = le(
+    this.options.staleTime,
+    n(this, c)
+  );
+  if (Ke.isServer() || n(this, S).isStale || !Ve(e))
+    return;
+  const i = _t(n(this, S).dataUpdatedAt, e) + 1;
+  u(this, $, ve.setTimeout(() => {
+    n(this, S).isStale || this.updateResult();
+  }, i));
+}, Ie = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(n(this, c)) : this.options.refetchInterval) ?? !1;
+}, Ce = function(e) {
+  b(this, d, Te).call(this), u(this, U, e), !(Ke.isServer() || _(this.options.enabled, n(this, c)) === !1 || !Ve(n(this, U)) || n(this, U) === 0) && u(this, K, ve.setInterval(() => {
+    (this.options.refetchIntervalInBackground || St.isFocused()) && b(this, d, ae).call(this);
+  }, n(this, U)));
+}, _e = function() {
+  b(this, d, Fe).call(this), b(this, d, Ce).call(this, b(this, d, Ie).call(this));
+}, je = function() {
+  n(this, $) !== void 0 && (ve.clearTimeout(n(this, $)), u(this, $, void 0));
+}, Te = function() {
+  n(this, K) !== void 0 && (ve.clearInterval(n(this, K)), u(this, K, void 0));
+}, Le = function() {
+  const e = n(this, E).getQueryCache().build(n(this, E), this.options);
+  if (e === n(this, c))
+    return;
+  const s = n(this, c);
+  u(this, c, e), u(this, ue, e.state), this.hasListeners() && (s == null || s.removeObserver(this), e.addObserver(this));
+}, st = function(e) {
+  Pt.batch(() => {
+    e.listeners && this.listeners.forEach((s) => {
+      s(n(this, S));
+    }), n(this, E).getQueryCache().notify({
+      query: n(this, c),
+      type: "observerResultsUpdated"
+    });
+  });
+}, et);
+function Nt(t, e) {
+  return _(e.enabled, t) !== !1 && t.state.data === void 0 && !(t.state.status === "error" && _(e.retryOnMount, t) === !1);
+}
+function He(t, e) {
+  return Nt(t, e) || t.state.data !== void 0 && ke(t, e, e.refetchOnMount);
+}
+function ke(t, e, s) {
+  if (_(e.enabled, t) !== !1 && le(e.staleTime, t) !== "static") {
+    const i = typeof s == "function" ? s(t) : s;
+    return i === "always" || i !== !1 && De(t, e);
+  }
+  return !1;
+}
+function Je(t, e, s, i) {
+  return (t !== e || _(i.enabled, t) === !1) && (!s.suspense || t.state.status !== "error") && De(t, s);
+}
+function De(t, e) {
+  return _(e.enabled, t) !== !1 && t.isStaleByTime(le(e.staleTime, t));
+}
+function Vt(t, e) {
+  return !Ee(t.getCurrentResult(), e);
+}
+var At = "VUE_QUERY_CLIENT";
+function zt(t) {
+  const e = t ? `:${t}` : "";
+  return `${At}${e}`;
+}
+function Ye(t, e) {
+  Object.keys(t).forEach((s) => {
+    t[s] = e[s];
+  });
+}
+function Pe(t, e, s = "", i = 0) {
+  if (e) {
+    const r = e(t, s, i);
+    if (r === void 0 && tt(t) || r !== void 0)
+      return r;
+  }
+  if (Array.isArray(t))
+    return t.map(
+      (r, o) => Pe(r, e, String(o), i + 1)
+    );
+  if (typeof t == "object" && qt(t)) {
+    const r = Object.entries(t).map(([o, h]) => [
+      o,
+      Pe(h, e, o, i + 1)
+    ]);
+    return Object.fromEntries(r);
+  }
+  return t;
+}
+function Bt(t, e) {
+  return Pe(t, e);
+}
+function be(t, e = !1) {
+  return Bt(t, (s, i, r) => {
+    if (r === 1 && i === "queryKey")
+      return be(s, !0);
+    if (e && $t(s))
+      return be(s(), e);
+    if (tt(s))
+      return be(me(s), e);
+  });
+}
+function qt(t) {
+  if (Object.prototype.toString.call(t) !== "[object Object]")
+    return !1;
+  const e = Object.getPrototypeOf(t);
+  return e === null || e === Object.prototype;
+}
+function $t(t) {
+  return typeof t == "function";
+}
+function Kt(t = "") {
+  if (!nt())
+    throw new Error(
+      "vue-query hooks can only be used inside setup() function or functions that support injection context."
+    );
+  const e = zt(t), s = it(e);
+  if (!s)
+    throw new Error(
+      "No 'queryClient' found in Vue context, use 'VueQueryPlugin' to properly initialize the library."
+    );
+  return s;
+}
+function Wt(t, e, s) {
+  process.env.NODE_ENV === "development" && (rt() || console.warn(
+    'vue-query composable like "useQuery()" should only be used inside a "setup()" function or a running effect scope. They might otherwise lead to memory leaks.'
+  ));
+  const i = Kt(), r = T(() => {
+    var O;
+    let a = e;
+    typeof a == "function" && (a = a());
+    const g = be(a);
+    typeof g.enabled == "function" && (g.enabled = g.enabled());
+    const j = i.defaultQueryOptions(g);
+    return j._optimisticResults = (O = i.isRestoring) != null && O.value ? "isRestoring" : "optimistic", j;
+  }), o = new t(i, r.value), h = r.value.shallow ? ot(o.getCurrentResult()) : at(o.getCurrentResult());
+  let l = () => {
+  };
+  i.isRestoring && Z(
+    i.isRestoring,
+    (a) => {
+      a || (l(), l = o.subscribe((g) => {
+        Ye(h, g);
+      }));
+    },
+    { immediate: !0 }
+  );
+  const m = () => {
+    o.setOptions(r.value), Ye(h, o.getCurrentResult());
+  };
+  Z(r, m), lt(() => {
+    l();
+  });
+  const I = (...a) => (m(), h.refetch(...a)), F = () => new Promise(
+    (a, g) => {
+      let j = () => {
+      };
+      const O = () => {
+        if (r.value.enabled !== !1) {
+          o.setOptions(r.value);
+          const x = o.getOptimisticResult(
+            r.value
+          );
+          x.isStale ? (j(), o.fetchOptimistic(r.value).then(a, (k) => {
+            $e(r.value.throwOnError, [
+              k,
+              o.getCurrentQuery()
+            ]) ? g(k) : a(o.getCurrentResult());
+          })) : (j(), a(x));
+        }
+      };
+      O(), j = Z(r, O);
+    }
+  );
+  Z(
+    () => h.error,
+    (a) => {
+      if (h.isError && !h.isFetching && $e(r.value.throwOnError, [
+        a,
+        o.getCurrentQuery()
+      ]))
+        throw a;
+    }
+  );
+  const f = r.value.shallow ? ut(h) : ct(h), y = ht(f);
+  for (const a in h)
+    typeof h[a] == "function" && (y[a] = h[a]);
+  return y.suspense = F, y.refetch = I, y;
+}
+function Se(t, e) {
+  return Wt(Ut, t);
+}
+const Ht = { class: "inline-flex rounded-md items-center gap-4 justify-center h-[30px] px-8 py-4 bg-fm-color-neutral-gray-100 cursor-pointer" }, Jt = { class: "fm-typo-en-body-md-600 select-none text-ellipsis overflow-hidden whitespace-nowrap" }, Yt = { class: "relative min-w-[280px]" }, Zt = { class: "sticky top-0 py-8 bg-white translate-y-[-12px]" }, Gt = {
+  key: 0,
+  class: "px-8 py-12 text-center fm-typo-en-body-md-400 text-fm-color-neutral-gray-500"
+}, ns = /* @__PURE__ */ dt({
+  __name: "AdminRestaurantSelector",
+  props: /* @__PURE__ */ gt({
+    label: {},
+    labelMark: {},
+    placeholder: {},
+    searchPlaceholder: {},
+    rules: {},
+    businessId: {}
+  }, {
+    modelValue: { default: "" },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(t) {
+    const e = t, s = ft(t, "modelValue"), { t: i } = Ot(), r = pt(e, "businessId"), o = Qe(""), h = Qe("");
+    let l = null;
+    Z(o, (p) => {
+      l && clearTimeout(l), l = setTimeout(() => h.value = p, 300);
+    }), Z(r, () => {
+      s.value = "";
+    });
+    const m = (p) => ({
+      label: p.profile.name,
+      value: p._id
+    }), I = T(
+      () => r.value ? ["admin-restaurants", "business", r.value] : ["admin-restaurants"]
+    ), { data: F, isLoading: f } = Se({
+      queryKey: I,
+      queryFn: () => we.readPaymentRestaurantsWithPagination({ limit: 20, businessId: r.value }).then((p) => p.data),
+      select: (p) => p.map(m)
+    }), { data: y, isLoading: a } = Se({
+      queryKey: T(() => [...I.value, "search", h.value]),
+      queryFn: () => we.readPaymentRestaurantsWithPagination({
+        limit: 20,
+        search: h.value,
+        businessId: r.value
+      }).then((p) => p.data),
+      select: (p) => p.map(m),
+      enabled: T(() => h.value.length > 0),
+      placeholderData: Tt
+    }), { data: g, isLoading: j } = Se({
+      queryKey: T(() => ["admin-restaurants", s.value]),
+      queryFn: () => we.readRestaurantById(s.value).then((p) => p ? m(p) : null),
+      enabled: T(
+        () => !!s.value && !(F.value ?? []).some((p) => p.value === s.value)
+      )
+    }), O = T(() => F.value ?? []), x = T(
+      () => o.value ? y.value ?? [] : O.value
+    ), k = T(
+      () => f.value || a.value || j.value
+    ), W = T(
+      () => O.value.find((p) => p.value === s.value) ?? g.value ?? void 0
+    ), re = T(
+      () => o.value && !k.value && x.value.length === 0
+    ), he = (p) => {
+      s.value = p, o.value = "";
+    };
+    return (p, N) => {
+      const C = Y("FmIcon"), de = Y("FmCircularProgress"), R = Y("FmSearch"), V = Y("FmMenuItem"), H = Y("FmMenu"), fe = Y("FmFormGroup");
+      return A(), oe(fe, {
+        modelValue: s.value,
+        "onUpdate:modelValue": N[2] || (N[2] = (w) => s.value = w),
+        label: e.label,
+        "label-mark": e.labelMark,
+        rules: e.rules
+      }, {
+        default: ge(() => [
+          Oe(H, { "close-on-click": !0 }, {
+            "menu-button": ge(() => {
+              var w;
+              return [
+                pe("div", Ht, [
+                  Oe(C, {
+                    name: "store",
+                    size: "sm"
+                  }),
+                  pe("div", Jt, Ne(((w = W.value) == null ? void 0 : w.label) ?? e.placeholder ?? me(i)("payment.components.select")), 1),
+                  k.value ? (A(), oe(de, {
+                    key: 0,
+                    size: "md"
+                  })) : W.value ? (A(), oe(C, {
+                    key: 1,
+                    name: "close",
+                    size: "sm",
+                    onClick: N[0] || (N[0] = yt((J) => s.value = "", ["stop"]))
+                  })) : (A(), oe(C, {
+                    key: 2,
+                    name: "expand_more",
+                    size: "sm"
+                  }))
+                ])
+              ];
+            }),
+            default: ge(() => [
+              pe("div", Yt, [
+                pe("div", Zt, [
+                  Oe(R, {
+                    "model-value": o.value,
+                    "onUpdate:modelValue": N[1] || (N[1] = (w) => o.value = w),
+                    placeholder: e.searchPlaceholder ?? e.placeholder ?? me(i)("payment.components.select")
+                  }, null, 8, ["model-value", "placeholder"])
+                ]),
+                (A(!0), Ue(vt, null, mt(x.value, (w) => (A(), oe(V, {
+                  key: w.value,
+                  label: w.label,
+                  sublabel: "Restaurant",
+                  onClick: (J) => he(w.value)
+                }, null, 8, ["label", "onClick"]))), 128)),
+                re.value ? (A(), Ue("div", Gt, Ne(me(i)("payment.components.no_results")), 1)) : bt("", !0)
+              ])
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["modelValue", "label", "label-mark", "rules"]);
+    };
+  }
+});
+export {
+  ns as _,
+  Tt as k,
+  Se as u
+};