@hortiview/modulebase 0.0.20436 → 1.0.0

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/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/api.js

@@ -1,9 +1,8 @@
-import { f as t, b as s, a as f, h as i } from "../api-CogBuK0n.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 u, f as m, i as S, b as I } from "../api-CogBuK0n.js";
 import { useBasePropsStore as t } from "../stores/BasePropsStore.js";
-const E = (s, e, g, o, r, n = !1) => {
-  const a = n ? void 0 : o ?? t.getState().modulePermissionToken, i = t.getState().organizationId, c = t.getState().currentLanguageId, d = t.getState().throwError;
-  if (!n && !a)
-    return d?.("No token found", 404), Promise.reject();
-  const f = u(a, i, c, g, r);
-  return f.body = JSON.stringify(e), m(s, f);
-}, h = (s, e, g, o = !1) => {
-  const r = o ? void 0 : g ?? t.getState().modulePermissionToken, n = t.getState().organizationId, a = t.getState().currentLanguageId, i = t.getState().throwError;
+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 i?.("No token found", 404), Promise.reject();
-  const c = u(r, n, a), d = S(e) ? "" : I(e);
-  return m(`${s}${d}`, c);
+    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 {
-  h as baseFetch,
-  E as baseMutation
+  I as baseFetch,
+  k as baseMutation
 };

package/dist/utils/fetches.js

@@ -1,15 +1,14 @@
 import { useBasePropsStore as a } from "../stores/BasePropsStore.js";
 import { useEnvironmentStore as i } from "../stores/EnvironmentStore.js";
 import { baseMutation as d, baseFetch as o } from "./baseFetches.js";
-const I = (e, t, n = "POST", s, m, u = !1) => d(e, t, n, s, m, u), g = (e, t) => r(`FarmOrgEntities/${e}/byId/${t}`), E = (e, t) => r(`ModuleDependentEntities/${e}/byId/${t}`), A = (e, t) => r(`ModuleDependentEntitiesRaw/${e}/byId/${t}`), M = (e, t, n = !1) => o(`${e}`, {}, t, n), r = (e) => {
+const I = (e, t, n = "POST", s, m, u = !1) => d(e, t, n, s, m, u), g = (e, t) => r(`FarmOrgEntities/${e}/byId/${t}`), E = (e, t) => r(`ModuleDependentEntities/${e}/byId/${t}`), A = (e, t) => r(`ModuleDependentEntitiesRaw/${e}/byId/${t}`), M = (e, t, n = !1) => o(`${e}`, t, n), r = (e) => {
   const t = i.getState().environment, n = a.getState().organizationId;
   return o(
-    `${t?.MODULE_AUTH_API}${t?.API_PREFIX}/${n}/${e}`,
-    {}
+    `${t?.MODULE_AUTH_API}${t?.API_PREFIX}/${n}/${e}`
   );
 }, f = (e) => {
   const t = i.getState().environment;
-  return o(`${t?.COMMON_API}${t?.API_PREFIX}/${e}`, {});
+  return o(`${t?.COMMON_API}${t?.API_PREFIX}/${e}`);
 };
 export {
   f as fetchFromCommonApi,

package/dist/utils/helper.js

@@ -10,22 +10,22 @@ const g = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([
 }, f = (r) => r === "*" || r === "x" || r === "X", l = (r) => {
   const e = parseInt(r, 10);
   return isNaN(e) ? r : e;
-}, h = (r, e) => typeof r != typeof e ? [String(r), String(e)] : [r, e], E = (r, e) => {
+}, v = (r, e) => typeof r != typeof e ? [String(r), String(e)] : [r, e], h = (r, e) => {
   if (f(r) || f(e))
     return 0;
-  const [n, t] = h(l(r), l(e));
-  return n > t ? 1 : n < t ? -1 : 0;
+  const [t, n] = v(l(r), l(e));
+  return t > n ? 1 : t < n ? -1 : 0;
 }, p = (r, e) => {
-  for (let n = 0; n < Math.max(r.length, e.length); n++) {
-    const t = E(r[n] || "0", e[n] || "0");
-    if (t !== 0)
-      return t;
+  for (let t = 0; t < Math.max(r.length, e.length); t++) {
+    const n = h(r[t] || "0", e[t] || "0");
+    if (n !== 0)
+      return n;
   }
   return 0;
-}, y = (r, e) => {
-  const n = c(r), t = c(e), o = n.pop(), i = t.pop(), s = p(n, t);
+}, E = (r, e) => {
+  const t = c(r), n = c(e), o = t.pop(), i = n.pop(), s = p(t, n);
   return s !== 0 ? s : o && i ? p(o.split("."), i.split(".")) : o || i ? o ? -1 : 1 : 0;
-}, d = "0.0.20436", w = (r) => m.every((e) => a(e, r)), a = (r, e) => {
+}, d = "0.0.13105-beta", w = (r) => m.every((e) => a(e, r)), a = (r, e) => {
   if (!e[r]) {
     if (e.throwError)
       return e.throwError(`Missing required prop: ${r}`, 404), !1;
@@ -39,10 +39,10 @@ const g = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([
 }, S = (r) => {
   if (!r?.REQ_VERSION) return null;
   const e = r.REQ_VERSION;
-  return y(d, e) < 0 ? `ModuleBase version ${d} is probably not compatible with the current HortiView version ${e}. Please update the modulebase to be at least ${e}` : null;
+  return E(d, e) < 0 ? `ModuleBase version ${d} is probably not compatible with the current HortiView version ${e}. Please update the modulebase to be at least ${e}` : null;
 }, _ = (r) => typeof r == "string" || typeof r == "boolean" || typeof r == "number" ? r : typeof r == "object" && "value" in r ? r.value : typeof r == "object" && "items" in r ? r.items : (Array.isArray(r), r), M = (r) => r, R = (r) => {
-  const e = u.getState().organizationId, n = u.getState().moduleId;
-  return [...r, e, n];
+  const e = u.getState().organizationId, t = u.getState().moduleId;
+  return [...r, e, t];
 };
 export {
   w as arePropsValid,