@hortiview/modulebase 0.0.16348 → 0.0.20524

package/dist/react-c9FSfB30.js

@@ -0,0 +1,27 @@
+import u from "react";
+const l = (t) => {
+  let e;
+  const n = /* @__PURE__ */ new Set(), o = (s, r) => {
+    const c = typeof s == "function" ? s(e) : s;
+    if (!Object.is(c, e)) {
+      const f = e;
+      e = r ?? (typeof c != "object" || c === null) ? c : Object.assign({}, e, c), n.forEach((g) => g(e, f));
+    }
+  }, a = () => e, i = { setState: o, getState: a, getInitialState: () => b, subscribe: (s) => (n.add(s), () => n.delete(s)) }, b = e = t(o, a, i);
+  return i;
+}, d = ((t) => t ? l(t) : l), I = (t) => t;
+function j(t, e = I) {
+  const n = u.useSyncExternalStore(
+    t.subscribe,
+    u.useCallback(() => e(t.getState()), [t, e]),
+    u.useCallback(() => e(t.getInitialState()), [t, e])
+  );
+  return u.useDebugValue(n), n;
+}
+const S = (t) => {
+  const e = d(t), n = (o) => j(e, o);
+  return Object.assign(n, e), n;
+}, O = ((t) => t ? S(t) : S);
+export {
+  O as c
+};

package/dist/stores/BasePropsStore.js

@@ -1,4 +1,4 @@
-import { c as o } from "../react-QiIgv49H.js";
+import { c as o } from "../react-c9FSfB30.js";
 const t = o((e) => ({
   setBaseProps: (s) => e({ ...s })
 }));

package/dist/stores/EnvironmentStore.js

@@ -1,4 +1,4 @@
-import { c as r } from "../react-QiIgv49H.js";
+import { c as r } from "../react-c9FSfB30.js";
 const E = r((e) => ({
   environment: {
     ENVIRONMENT: "DEV",

package/dist/types/ActionStorage.js

@@ -0,0 +1 @@
+

package/dist/types/Entities.js

@@ -0,0 +1,25 @@
+const e = {
+  farms: "farm",
+  fields: "field",
+  zones: "block",
+  irrigation_stations: "irrigationStation",
+  farm_organizations: "farmOrg",
+  alert_rules: "farmAlertRule"
+}, t = {
+  farm_members: "member"
+}, a = {
+  Season: "season",
+  BlockPlantLayout: "blockPlantLayout",
+  Record: "recordLight",
+  Scouting: "scouting"
+}, r = {
+  ...e,
+  ...t,
+  ...a
+};
+export {
+  r as AllEntitiesTypeResultMap,
+  t as FarmMemberEntitiesTypeResultMap,
+  e as FarmOrgEntitiesTypeResultMap,
+  a as ModuleDependedEntityTypeResultMap
+};

package/dist/useMutation-Aoachkw_.js

@@ -0,0 +1,139 @@
+import * as o from "react";
+import { g as l } from "./mutation-CmhiEgfA.js";
+import { S as d, s as m, h as a, n as h, u as p, a as b, b as v } from "./QueryClientProvider-DyiNrPkn.js";
+var f = class extends d {
+  #s;
+  #i = void 0;
+  #t;
+  #e;
+  constructor(t, s) {
+    super(), this.#s = t, this.setOptions(s), this.bindMethods(), this.#r();
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(t) {
+    const s = this.options;
+    this.options = this.#s.defaultMutationOptions(t), m(this.options, s) || this.#s.getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: this.#t,
+      observer: this
+    }), s?.mutationKey && this.options.mutationKey && a(s.mutationKey) !== a(this.options.mutationKey) ? this.reset() : this.#t?.state.status === "pending" && this.#t.setOptions(this.options);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.#t?.removeObserver(this);
+  }
+  onMutationUpdate(t) {
+    this.#r(), this.#o(t);
+  }
+  getCurrentResult() {
+    return this.#i;
+  }
+  reset() {
+    this.#t?.removeObserver(this), this.#t = void 0, this.#r(), this.#o();
+  }
+  mutate(t, s) {
+    return this.#e = s, this.#t?.removeObserver(this), this.#t = this.#s.getMutationCache().build(this.#s, this.options), this.#t.addObserver(this), this.#t.execute(t);
+  }
+  #r() {
+    const t = this.#t?.state ?? l();
+    this.#i = {
+      ...t,
+      isPending: t.status === "pending",
+      isSuccess: t.status === "success",
+      isError: t.status === "error",
+      isIdle: t.status === "idle",
+      mutate: this.mutate,
+      reset: this.reset
+    };
+  }
+  #o(t) {
+    h.batch(() => {
+      if (this.#e && this.hasListeners()) {
+        const s = this.#i.variables, r = this.#i.context, e = {
+          client: this.#s,
+          meta: this.options.meta,
+          mutationKey: this.options.mutationKey
+        };
+        if (t?.type === "success") {
+          try {
+            this.#e.onSuccess?.(
+              t.data,
+              s,
+              r,
+              e
+            );
+          } catch (i) {
+            Promise.reject(i);
+          }
+          try {
+            this.#e.onSettled?.(
+              t.data,
+              null,
+              s,
+              r,
+              e
+            );
+          } catch (i) {
+            Promise.reject(i);
+          }
+        } else if (t?.type === "error") {
+          try {
+            this.#e.onError?.(
+              t.error,
+              s,
+              r,
+              e
+            );
+          } catch (i) {
+            Promise.reject(i);
+          }
+          try {
+            this.#e.onSettled?.(
+              void 0,
+              t.error,
+              s,
+              r,
+              e
+            );
+          } catch (i) {
+            Promise.reject(i);
+          }
+        }
+      }
+      this.listeners.forEach((s) => {
+        s(this.#i);
+      });
+    });
+  }
+};
+function g(t, s) {
+  const r = p(s), [e] = o.useState(
+    () => new f(
+      r,
+      t
+    )
+  );
+  o.useEffect(() => {
+    e.setOptions(t);
+  }, [e, t]);
+  const i = o.useSyncExternalStore(
+    o.useCallback(
+      (n) => e.subscribe(h.batchCalls(n)),
+      [e]
+    ),
+    () => e.getCurrentResult(),
+    () => e.getCurrentResult()
+  ), u = o.useCallback(
+    (n, c) => {
+      e.mutate(n, c).catch(b);
+    },
+    [e]
+  );
+  if (i.error && v(e.options.throwOnError, [i.error]))
+    throw i.error;
+  return { ...i, mutate: u, mutateAsync: i.mutate };
+}
+export {
+  g as u
+};

package/dist/useQuery-DEU_AUtf.js

@@ -0,0 +1,392 @@
+import { S as z, p as L, d as l, s as M, f as v, a as Q, j as _, k as j, t as K, l as w, m as $, r as A, n as W, b as q, u as G } from "./QueryClientProvider-DyiNrPkn.js";
+import { f as J, u as X } from "./IsRestoringProvider-CBSZo7ur.js";
+import * as m from "react";
+import "react/jsx-runtime";
+var Y = class extends z {
+  constructor(t, e) {
+    super(), this.options = e, this.#s = t, this.#i = null, this.#r = L(), this.bindMethods(), this.setOptions(e);
+  }
+  #s;
+  #t = void 0;
+  #p = void 0;
+  #e = void 0;
+  #n;
+  #u;
+  #r;
+  #i;
+  #m;
+  #l;
+  // 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.
+  #d;
+  #o;
+  #h;
+  #a;
+  #f = /* @__PURE__ */ new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (this.#t.addObserver(this), B(this.#t, this.options) ? this.#c() : this.updateResult(), this.#v());
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return F(
+      this.#t,
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return F(
+      this.#t,
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), this.#R(), this.#S(), this.#t.removeObserver(this);
+  }
+  setOptions(t) {
+    const e = this.options, s = this.#t;
+    if (this.options = this.#s.defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof l(this.options.enabled, this.#t) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    this.#E(), this.#t.setOptions(this.options), e._defaulted && !M(this.options, e) && this.#s.getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: this.#t,
+      observer: this
+    });
+    const r = this.hasListeners();
+    r && H(
+      this.#t,
+      s,
+      this.options,
+      e
+    ) && this.#c(), this.updateResult(), r && (this.#t !== s || l(this.options.enabled, this.#t) !== l(e.enabled, this.#t) || v(this.options.staleTime, this.#t) !== v(e.staleTime, this.#t)) && this.#b();
+    const i = this.#y();
+    r && (this.#t !== s || l(this.options.enabled, this.#t) !== l(e.enabled, this.#t) || i !== this.#a) && this.#g(i);
+  }
+  getOptimisticResult(t) {
+    const e = this.#s.getQueryCache().build(this.#s, t), s = this.createResult(e, t);
+    return tt(this, s) && (this.#e = s, this.#u = this.options, this.#n = this.#t.state), s;
+  }
+  getCurrentResult() {
+    return this.#e;
+  }
+  trackResult(t, e) {
+    return new Proxy(t, {
+      get: (s, r) => (this.trackProp(r), e?.(r), r === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && this.#r.status === "pending" && this.#r.reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      )), Reflect.get(s, r))
+    });
+  }
+  trackProp(t) {
+    this.#f.add(t);
+  }
+  getCurrentQuery() {
+    return this.#t;
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const e = this.#s.defaultQueryOptions(t), s = this.#s.getQueryCache().build(this.#s, e);
+    return s.fetch().then(() => this.createResult(s, e));
+  }
+  fetch(t) {
+    return this.#c({
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), this.#e));
+  }
+  #c(t) {
+    this.#E();
+    let e = this.#t.fetch(
+      this.options,
+      t
+    );
+    return t?.throwOnError || (e = e.catch(Q)), e;
+  }
+  #b() {
+    this.#R();
+    const t = v(
+      this.options.staleTime,
+      this.#t
+    );
+    if (_ || this.#e.isStale || !j(t))
+      return;
+    const s = K(this.#e.dataUpdatedAt, t) + 1;
+    this.#o = w.setTimeout(() => {
+      this.#e.isStale || this.updateResult();
+    }, s);
+  }
+  #y() {
+    return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(this.#t) : this.options.refetchInterval) ?? !1;
+  }
+  #g(t) {
+    this.#S(), this.#a = t, !(_ || l(this.options.enabled, this.#t) === !1 || !j(this.#a) || this.#a === 0) && (this.#h = w.setInterval(() => {
+      (this.options.refetchIntervalInBackground || $.isFocused()) && this.#c();
+    }, this.#a));
+  }
+  #v() {
+    this.#b(), this.#g(this.#y());
+  }
+  #R() {
+    this.#o && (w.clearTimeout(this.#o), this.#o = void 0);
+  }
+  #S() {
+    this.#h && (w.clearInterval(this.#h), this.#h = void 0);
+  }
+  createResult(t, e) {
+    const s = this.#t, r = this.options, i = this.#e, u = this.#n, a = this.#u, b = t !== s ? t.state : this.#p, { state: h } = t;
+    let n = { ...h }, y = !1, o;
+    if (e._optimisticResults) {
+      const c = this.hasListeners(), g = !c && B(t, e), S = c && H(t, s, e, r);
+      (g || S) && (n = {
+        ...n,
+        ...J(h.data, t.options)
+      }), e._optimisticResults === "isRestoring" && (n.fetchStatus = "idle");
+    }
+    let { error: R, errorUpdatedAt: x, status: p } = n;
+    o = n.data;
+    let U = !1;
+    if (e.placeholderData !== void 0 && o === void 0 && p === "pending") {
+      let c;
+      i?.isPlaceholderData && e.placeholderData === a?.placeholderData ? (c = i.data, U = !0) : c = typeof e.placeholderData == "function" ? e.placeholderData(
+        this.#d?.state.data,
+        this.#d
+      ) : e.placeholderData, c !== void 0 && (p = "success", o = A(
+        i?.data,
+        c,
+        e
+      ), y = !0);
+    }
+    if (e.select && o !== void 0 && !U)
+      if (i && o === u?.data && e.select === this.#m)
+        o = this.#l;
+      else
+        try {
+          this.#m = e.select, o = e.select(o), o = A(i?.data, o, e), this.#l = o, this.#i = null;
+        } catch (c) {
+          this.#i = c;
+        }
+    this.#i && (R = this.#i, o = this.#l, x = Date.now(), p = "error");
+    const C = n.fetchStatus === "fetching", I = p === "pending", T = p === "error", D = I && C, k = o !== void 0, f = {
+      status: p,
+      fetchStatus: n.fetchStatus,
+      isPending: I,
+      isSuccess: p === "success",
+      isError: T,
+      isInitialLoading: D,
+      isLoading: D,
+      data: o,
+      dataUpdatedAt: n.dataUpdatedAt,
+      error: R,
+      errorUpdatedAt: x,
+      failureCount: n.fetchFailureCount,
+      failureReason: n.fetchFailureReason,
+      errorUpdateCount: n.errorUpdateCount,
+      isFetched: n.dataUpdateCount > 0 || n.errorUpdateCount > 0,
+      isFetchedAfterMount: n.dataUpdateCount > b.dataUpdateCount || n.errorUpdateCount > b.errorUpdateCount,
+      isFetching: C,
+      isRefetching: C && !I,
+      isLoadingError: T && !k,
+      isPaused: n.fetchStatus === "paused",
+      isPlaceholderData: y,
+      isRefetchError: T && k,
+      isStale: P(t, e),
+      refetch: this.refetch,
+      promise: this.#r,
+      isEnabled: l(e.enabled, t) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const c = f.data !== void 0, g = f.status === "error" && !c, S = (O) => {
+        g ? O.reject(f.error) : c && O.resolve(f.data);
+      }, N = () => {
+        const O = this.#r = f.promise = L();
+        S(O);
+      }, E = this.#r;
+      switch (E.status) {
+        case "pending":
+          t.queryHash === s.queryHash && S(E);
+          break;
+        case "fulfilled":
+          (g || f.data !== E.value) && N();
+          break;
+        case "rejected":
+          (!g || f.error !== E.reason) && N();
+          break;
+      }
+    }
+    return f;
+  }
+  updateResult() {
+    const t = this.#e, e = this.createResult(this.#t, this.options);
+    if (this.#n = this.#t.state, this.#u = this.options, this.#n.data !== void 0 && (this.#d = this.#t), M(e, t))
+      return;
+    this.#e = e;
+    const s = () => {
+      if (!t)
+        return !0;
+      const { notifyOnChangeProps: r } = this.options, i = typeof r == "function" ? r() : r;
+      if (i === "all" || !i && !this.#f.size)
+        return !0;
+      const u = new Set(
+        i ?? this.#f
+      );
+      return this.options.throwOnError && u.add("error"), Object.keys(this.#e).some((a) => {
+        const d = a;
+        return this.#e[d] !== t[d] && u.has(d);
+      });
+    };
+    this.#O({ listeners: s() });
+  }
+  #E() {
+    const t = this.#s.getQueryCache().build(this.#s, this.options);
+    if (t === this.#t)
+      return;
+    const e = this.#t;
+    this.#t = t, this.#p = t.state, this.hasListeners() && (e?.removeObserver(this), t.addObserver(this));
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && this.#v();
+  }
+  #O(t) {
+    W.batch(() => {
+      t.listeners && this.listeners.forEach((e) => {
+        e(this.#e);
+      }), this.#s.getQueryCache().notify({
+        query: this.#t,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function Z(t, e) {
+  return l(e.enabled, t) !== !1 && t.state.data === void 0 && !(t.state.status === "error" && e.retryOnMount === !1);
+}
+function B(t, e) {
+  return Z(t, e) || t.state.data !== void 0 && F(t, e, e.refetchOnMount);
+}
+function F(t, e, s) {
+  if (l(e.enabled, t) !== !1 && v(e.staleTime, t) !== "static") {
+    const r = typeof s == "function" ? s(t) : s;
+    return r === "always" || r !== !1 && P(t, e);
+  }
+  return !1;
+}
+function H(t, e, s, r) {
+  return (t !== e || l(r.enabled, t) === !1) && (!s.suspense || t.state.status !== "error") && P(t, s);
+}
+function P(t, e) {
+  return l(e.enabled, t) !== !1 && t.isStaleByTime(v(e.staleTime, t));
+}
+function tt(t, e) {
+  return !M(t.getCurrentResult(), e);
+}
+function et() {
+  let t = !1;
+  return {
+    clearReset: () => {
+      t = !1;
+    },
+    reset: () => {
+      t = !0;
+    },
+    isReset: () => t
+  };
+}
+var st = m.createContext(et()), rt = () => m.useContext(st), it = (t, e, s) => {
+  const r = s?.state.error && typeof t.throwOnError == "function" ? q(t.throwOnError, [s.state.error, s]) : t.throwOnError;
+  (t.suspense || t.experimental_prefetchInRender || r) && (e.isReset() || (t.retryOnMount = !1));
+}, at = (t) => {
+  m.useEffect(() => {
+    t.clearReset();
+  }, [t]);
+}, nt = ({
+  result: t,
+  errorResetBoundary: e,
+  throwOnError: s,
+  query: r,
+  suspense: i
+}) => t.isError && !e.isReset() && !t.isFetching && r && (i && t.data === void 0 || q(s, [t.error, r])), ot = (t) => {
+  if (t.suspense) {
+    const s = (i) => i === "static" ? i : Math.max(i ?? 1e3, 1e3), r = t.staleTime;
+    t.staleTime = typeof r == "function" ? (...i) => s(r(...i)) : s(r), typeof t.gcTime == "number" && (t.gcTime = Math.max(
+      t.gcTime,
+      1e3
+    ));
+  }
+}, ht = (t, e) => t.isLoading && t.isFetching && !e, ct = (t, e) => t?.suspense && e.isPending, V = (t, e, s) => e.fetchOptimistic(t).catch(() => {
+  s.clearReset();
+});
+function ut(t, e, s) {
+  if (process.env.NODE_ENV !== "production" && (typeof t != "object" || Array.isArray(t)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const r = X(), i = rt(), u = G(s), a = u.defaultQueryOptions(t);
+  u.getDefaultOptions().queries?._experimental_beforeQuery?.(
+    a
+  );
+  const d = u.getQueryCache().get(a.queryHash);
+  process.env.NODE_ENV !== "production" && (a.queryFn || console.error(
+    `[${a.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+  )), a._optimisticResults = r ? "isRestoring" : "optimistic", ot(a), it(a, i, d), at(i);
+  const b = !u.getQueryCache().get(a.queryHash), [h] = m.useState(
+    () => new e(
+      u,
+      a
+    )
+  ), n = h.getOptimisticResult(a), y = !r && t.subscribed !== !1;
+  if (m.useSyncExternalStore(
+    m.useCallback(
+      (o) => {
+        const R = y ? h.subscribe(W.batchCalls(o)) : Q;
+        return h.updateResult(), R;
+      },
+      [h, y]
+    ),
+    () => h.getCurrentResult(),
+    () => h.getCurrentResult()
+  ), m.useEffect(() => {
+    h.setOptions(a);
+  }, [a, h]), ct(a, n))
+    throw V(a, h, i);
+  if (nt({
+    result: n,
+    errorResetBoundary: i,
+    throwOnError: a.throwOnError,
+    query: d,
+    suspense: a.suspense
+  }))
+    throw n.error;
+  return u.getDefaultOptions().queries?._experimental_afterQuery?.(
+    a,
+    n
+  ), a.experimental_prefetchInRender && !_ && ht(n, r) && (b ? (
+    // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+    V(a, h, i)
+  ) : (
+    // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+    d?.promise
+  ))?.catch(Q).finally(() => {
+    h.updateResult();
+  }), a.notifyOnChangeProps ? n : h.trackResult(n);
+}
+function mt(t, e) {
+  return ut(t, Y, e);
+}
+export {
+  Y as Q,
+  ut as a,
+  mt as u
+};

package/dist/utils/IndexedDbService.js

@@ -0,0 +1,43 @@
+function a(e) {
+  return new Promise((n, t) => {
+    e.oncomplete = e.onsuccess = () => n(e.result), e.onabort = e.onerror = () => t(e.error);
+  });
+}
+function s(e, n) {
+  let t;
+  const o = () => {
+    if (t)
+      return t;
+    const r = indexedDB.open(e);
+    return r.onupgradeneeded = () => r.result.createObjectStore(n), t = a(r), t.then((c) => {
+      c.onclose = () => t = void 0;
+    }, () => {
+    }), t;
+  };
+  return (r, c) => o().then((d) => c(d.transaction(n, r).objectStore(n)));
+}
+let u;
+function i() {
+  return u || (u = s("keyval-store", "keyval")), u;
+}
+function l(e, n = i()) {
+  return n("readonly", (t) => a(t.get(e)));
+}
+function f(e, n, t = i()) {
+  return t("readwrite", (o) => (o.put(n, e), a(o.transaction)));
+}
+function p(e, n = i()) {
+  return n("readwrite", (t) => (t.delete(e), a(t.transaction)));
+}
+const y = {
+  getItem: async (e) => await l(e),
+  setItem: async (e, n) => {
+    await f(e, n);
+  },
+  removeItem: async (e) => {
+    await p(e);
+  }
+};
+export {
+  y as indexedDbStorage
+};

package/dist/utils/api.js

@@ -1,9 +1,8 @@
-import { f as t, b as s, a as f, h as i } from "../api-D9Lmqe6S.js";
+import { f as t, a as i, h as n } from "../api-COabZnyn.js";
 import "../constants.js";
 import "../stores/BasePropsStore.js";
 export {
   t as fetchWithErrorHandling,
-  s as formatQuery,
-  f as getConfig,
-  i as handleResponse
+  i as getConfig,
+  n as handleResponse
 };

package/dist/utils/baseFetches.js

@@ -1,19 +1,23 @@
-import { a as d, f, i as m, b as S } from "../api-D9Lmqe6S.js";
 import { useBasePropsStore as t } from "../stores/BasePropsStore.js";
-const k = (n, o, a, e, s) => {
-  const r = e ?? t.getState().modulePermissionToken, g = t.getState().organizationId, i = t.getState().currentLanguageId, c = t.getState().throwError;
-  if (!r)
-    return c?.("No token found", 404), Promise.reject();
-  const u = d(r, g, i, a, s);
-  return u.body = JSON.stringify(o), f(n, u);
-}, E = (n, o, a) => {
-  const e = a ?? t.getState().modulePermissionToken, s = t.getState().organizationId, r = t.getState().currentLanguageId, g = t.getState().throwError;
-  if (!e)
-    return g?.("No token found", 404), Promise.reject();
-  const i = d(e, s, r), c = m(o) ? "" : S(o);
-  return f(`${n}${c}`, i);
+import { a as u, f } from "../api-COabZnyn.js";
+const k = (a, s, e, i, g, o = !1) => {
+  const r = o ? void 0 : i ?? t.getState().modulePermissionToken, n = t.getState().organizationId, c = t.getState().currentLanguageId, l = t.getState().throwError;
+  if (!o && !r)
+    return l?.("No token found", 404), Promise.reject();
+  const d = u(r, n, c, e, g);
+  return d.body = JSON.stringify(s), f(a, d);
+}, I = (a, s, e = !1) => {
+  const i = t.getState().modulePermissionToken, g = t.getState().organizationId, o = t.getState().currentLanguageId, r = t.getState().throwError, n = e ? void 0 : s ?? i;
+  if (!e && !n)
+    return r?.("No token available", 401), Promise.reject(
+      new Error("No token available", {
+        cause: 401
+      })
+    );
+  const c = u(n, g, o);
+  return f(a, c);
 };
 export {
-  E as baseFetch,
+  I as baseFetch,
   k as baseMutation
 };