@hortiview/modulebase 1.1.2-alpha.870da389.1 → 2.0.0-alpha.e897c28d.1

package/dist/constants.js

@@ -1,10 +1,9 @@
 const a = [
   "addBreadcrumbTranslation",
-  "navigateInHortiview",
   "modulePermissionToken",
   "organizationId",
   "currentLanguageId",
-  "currentNavigationPath"
+  "basePath"
 ], e = {
   /**
    * The server timed out waiting for the request.

package/dist/defaultQueryClient-Cfsorhtn.js

@@ -0,0 +1,620 @@
+import { R as v, e as O, n as u, S as m, m as c, c as o, f as g, Q, g as l, i as M, o as d, r as f, j as b, b as y, p, k as w } from "./query-DZDIN635.js";
+var P = class extends v {
+  #t;
+  #e;
+  #s;
+  #r;
+  constructor(t) {
+    super(), this.#t = t.client, this.mutationId = t.mutationId, this.#s = t.mutationCache, this.#e = [], this.state = t.state || x(), this.setOptions(t.options), this.scheduleGc();
+  }
+  setOptions(t) {
+    this.options = t, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(t) {
+    this.#e.includes(t) || (this.#e.push(t), this.clearGcTimeout(), this.#s.notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: t
+    }));
+  }
+  removeObserver(t) {
+    this.#e = this.#e.filter((e) => e !== t), this.scheduleGc(), this.#s.notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: t
+    });
+  }
+  optionalRemove() {
+    this.#e.length || (this.state.status === "pending" ? this.scheduleGc() : this.#s.remove(this));
+  }
+  continue() {
+    return this.#r?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(t) {
+    const e = () => {
+      this.#i({ type: "continue" });
+    }, s = {
+      client: this.#t,
+      meta: this.options.meta,
+      mutationKey: this.options.mutationKey
+    };
+    this.#r = O({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t, s) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (r, a) => {
+        this.#i({ type: "failed", failureCount: r, error: a });
+      },
+      onPause: () => {
+        this.#i({ type: "pause" });
+      },
+      onContinue: e,
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => this.#s.canRun(this)
+    });
+    const i = this.state.status === "pending", n = !this.#r.canStart();
+    try {
+      if (i)
+        e();
+      else {
+        this.#i({ type: "pending", variables: t, isPaused: n }), this.#s.config.onMutate && await this.#s.config.onMutate(
+          t,
+          this,
+          s
+        );
+        const a = await this.options.onMutate?.(
+          t,
+          s
+        );
+        a !== this.state.context && this.#i({
+          type: "pending",
+          context: a,
+          variables: t,
+          isPaused: n
+        });
+      }
+      const r = await this.#r.start();
+      return await this.#s.config.onSuccess?.(
+        r,
+        t,
+        this.state.context,
+        this,
+        s
+      ), await this.options.onSuccess?.(
+        r,
+        t,
+        this.state.context,
+        s
+      ), await this.#s.config.onSettled?.(
+        r,
+        null,
+        this.state.variables,
+        this.state.context,
+        this,
+        s
+      ), await this.options.onSettled?.(
+        r,
+        null,
+        t,
+        this.state.context,
+        s
+      ), this.#i({ type: "success", data: r }), r;
+    } catch (r) {
+      try {
+        await this.#s.config.onError?.(
+          r,
+          t,
+          this.state.context,
+          this,
+          s
+        );
+      } catch (a) {
+        Promise.reject(a);
+      }
+      try {
+        await this.options.onError?.(
+          r,
+          t,
+          this.state.context,
+          s
+        );
+      } catch (a) {
+        Promise.reject(a);
+      }
+      try {
+        await this.#s.config.onSettled?.(
+          void 0,
+          r,
+          this.state.variables,
+          this.state.context,
+          this,
+          s
+        );
+      } catch (a) {
+        Promise.reject(a);
+      }
+      try {
+        await this.options.onSettled?.(
+          void 0,
+          r,
+          t,
+          this.state.context,
+          s
+        );
+      } catch (a) {
+        Promise.reject(a);
+      }
+      throw this.#i({ type: "error", error: r }), r;
+    } finally {
+      this.#s.runNext(this);
+    }
+  }
+  #i(t) {
+    const e = (s) => {
+      switch (t.type) {
+        case "failed":
+          return {
+            ...s,
+            failureCount: t.failureCount,
+            failureReason: t.error
+          };
+        case "pause":
+          return {
+            ...s,
+            isPaused: !0
+          };
+        case "continue":
+          return {
+            ...s,
+            isPaused: !1
+          };
+        case "pending":
+          return {
+            ...s,
+            context: t.context,
+            data: void 0,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: t.isPaused,
+            status: "pending",
+            variables: t.variables,
+            submittedAt: Date.now()
+          };
+        case "success":
+          return {
+            ...s,
+            data: t.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: "success",
+            isPaused: !1
+          };
+        case "error":
+          return {
+            ...s,
+            data: void 0,
+            error: t.error,
+            failureCount: s.failureCount + 1,
+            failureReason: t.error,
+            isPaused: !1,
+            status: "error"
+          };
+      }
+    };
+    this.state = e(this.state), u.batch(() => {
+      this.#e.forEach((s) => {
+        s.onMutationUpdate(t);
+      }), this.#s.notify({
+        mutation: this,
+        type: "updated",
+        action: t
+      });
+    });
+  }
+};
+function x() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var C = class extends m {
+  constructor(t = {}) {
+    super(), this.config = t, this.#t = /* @__PURE__ */ new Set(), this.#e = /* @__PURE__ */ new Map(), this.#s = 0;
+  }
+  #t;
+  #e;
+  #s;
+  build(t, e, s) {
+    const i = new P({
+      client: t,
+      mutationCache: this,
+      mutationId: ++this.#s,
+      options: t.defaultMutationOptions(e),
+      state: s
+    });
+    return this.add(i), i;
+  }
+  add(t) {
+    this.#t.add(t);
+    const e = h(t);
+    if (typeof e == "string") {
+      const s = this.#e.get(e);
+      s ? s.push(t) : this.#e.set(e, [t]);
+    }
+    this.notify({ type: "added", mutation: t });
+  }
+  remove(t) {
+    if (this.#t.delete(t)) {
+      const e = h(t);
+      if (typeof e == "string") {
+        const s = this.#e.get(e);
+        if (s)
+          if (s.length > 1) {
+            const i = s.indexOf(t);
+            i !== -1 && s.splice(i, 1);
+          } else s[0] === t && this.#e.delete(e);
+      }
+    }
+    this.notify({ type: "removed", mutation: t });
+  }
+  canRun(t) {
+    const e = h(t);
+    if (typeof e == "string") {
+      const i = this.#e.get(e)?.find(
+        (n) => n.state.status === "pending"
+      );
+      return !i || i === t;
+    } else
+      return !0;
+  }
+  runNext(t) {
+    const e = h(t);
+    return typeof e == "string" ? this.#e.get(e)?.find((i) => i !== t && i.state.isPaused)?.continue() ?? Promise.resolve() : Promise.resolve();
+  }
+  clear() {
+    u.batch(() => {
+      this.#t.forEach((t) => {
+        this.notify({ type: "removed", mutation: t });
+      }), this.#t.clear(), this.#e.clear();
+    });
+  }
+  getAll() {
+    return Array.from(this.#t);
+  }
+  find(t) {
+    const e = { exact: !0, ...t };
+    return this.getAll().find(
+      (s) => c(e, s)
+    );
+  }
+  findAll(t = {}) {
+    return this.getAll().filter((e) => c(t, e));
+  }
+  notify(t) {
+    u.batch(() => {
+      this.listeners.forEach((e) => {
+        e(t);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const t = this.getAll().filter((e) => e.state.isPaused);
+    return u.batch(
+      () => Promise.all(
+        t.map((e) => e.continue().catch(o))
+      )
+    );
+  }
+};
+function h(t) {
+  return t.options.scope?.id;
+}
+var A = class extends m {
+  constructor(t = {}) {
+    super(), this.config = t, this.#t = /* @__PURE__ */ new Map();
+  }
+  #t;
+  build(t, e, s) {
+    const i = e.queryKey, n = e.queryHash ?? g(i, e);
+    let r = this.get(n);
+    return r || (r = new Q({
+      client: t,
+      queryKey: i,
+      queryHash: n,
+      options: t.defaultQueryOptions(e),
+      state: s,
+      defaultOptions: t.getQueryDefaults(i)
+    }), this.add(r)), r;
+  }
+  add(t) {
+    this.#t.has(t.queryHash) || (this.#t.set(t.queryHash, t), this.notify({
+      type: "added",
+      query: t
+    }));
+  }
+  remove(t) {
+    const e = this.#t.get(t.queryHash);
+    e && (t.destroy(), e === t && this.#t.delete(t.queryHash), this.notify({ type: "removed", query: t }));
+  }
+  clear() {
+    u.batch(() => {
+      this.getAll().forEach((t) => {
+        this.remove(t);
+      });
+    });
+  }
+  get(t) {
+    return this.#t.get(t);
+  }
+  getAll() {
+    return [...this.#t.values()];
+  }
+  find(t) {
+    const e = { exact: !0, ...t };
+    return this.getAll().find(
+      (s) => l(e, s)
+    );
+  }
+  findAll(t = {}) {
+    const e = this.getAll();
+    return Object.keys(t).length > 0 ? e.filter((s) => l(t, s)) : e;
+  }
+  notify(t) {
+    u.batch(() => {
+      this.listeners.forEach((e) => {
+        e(t);
+      });
+    });
+  }
+  onFocus() {
+    u.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    u.batch(() => {
+      this.getAll().forEach((t) => {
+        t.onOnline();
+      });
+    });
+  }
+}, D = class {
+  #t;
+  #e;
+  #s;
+  #r;
+  #i;
+  #n;
+  #a;
+  #u;
+  constructor(t = {}) {
+    this.#t = t.queryCache || new A(), this.#e = t.mutationCache || new C(), this.#s = t.defaultOptions || {}, this.#r = /* @__PURE__ */ new Map(), this.#i = /* @__PURE__ */ new Map(), this.#n = 0;
+  }
+  mount() {
+    this.#n++, this.#n === 1 && (this.#a = M.subscribe(async (t) => {
+      t && (await this.resumePausedMutations(), this.#t.onFocus());
+    }), this.#u = d.subscribe(async (t) => {
+      t && (await this.resumePausedMutations(), this.#t.onOnline());
+    }));
+  }
+  unmount() {
+    this.#n--, this.#n === 0 && (this.#a?.(), this.#a = void 0, this.#u?.(), this.#u = void 0);
+  }
+  isFetching(t) {
+    return this.#t.findAll({ ...t, fetchStatus: "fetching" }).length;
+  }
+  isMutating(t) {
+    return this.#e.findAll({ ...t, status: "pending" }).length;
+  }
+  /**
+   * Imperative (non-reactive) way to retrieve data for a QueryKey.
+   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+   *
+   * Hint: Do not use this function inside a component, because it won't receive updates.
+   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+   */
+  getQueryData(t) {
+    const e = this.defaultQueryOptions({ queryKey: t });
+    return this.#t.get(e.queryHash)?.state.data;
+  }
+  ensureQueryData(t) {
+    const e = this.defaultQueryOptions(t), s = this.#t.build(this, e), i = s.state.data;
+    return i === void 0 ? this.fetchQuery(t) : (t.revalidateIfStale && s.isStaleByTime(f(e.staleTime, s)) && this.prefetchQuery(e), Promise.resolve(i));
+  }
+  getQueriesData(t) {
+    return this.#t.findAll(t).map(({ queryKey: e, state: s }) => {
+      const i = s.data;
+      return [e, i];
+    });
+  }
+  setQueryData(t, e, s) {
+    const i = this.defaultQueryOptions({ queryKey: t }), r = this.#t.get(
+      i.queryHash
+    )?.state.data, a = b(e, r);
+    if (a !== void 0)
+      return this.#t.build(this, i).setData(a, { ...s, manual: !0 });
+  }
+  setQueriesData(t, e, s) {
+    return u.batch(
+      () => this.#t.findAll(t).map(({ queryKey: i }) => [
+        i,
+        this.setQueryData(i, e, s)
+      ])
+    );
+  }
+  getQueryState(t) {
+    const e = this.defaultQueryOptions({ queryKey: t });
+    return this.#t.get(
+      e.queryHash
+    )?.state;
+  }
+  removeQueries(t) {
+    const e = this.#t;
+    u.batch(() => {
+      e.findAll(t).forEach((s) => {
+        e.remove(s);
+      });
+    });
+  }
+  resetQueries(t, e) {
+    const s = this.#t;
+    return u.batch(() => (s.findAll(t).forEach((i) => {
+      i.reset();
+    }), this.refetchQueries(
+      {
+        type: "active",
+        ...t
+      },
+      e
+    )));
+  }
+  cancelQueries(t, e = {}) {
+    const s = { revert: !0, ...e }, i = u.batch(
+      () => this.#t.findAll(t).map((n) => n.cancel(s))
+    );
+    return Promise.all(i).then(o).catch(o);
+  }
+  invalidateQueries(t, e = {}) {
+    return u.batch(() => (this.#t.findAll(t).forEach((s) => {
+      s.invalidate();
+    }), t?.refetchType === "none" ? Promise.resolve() : this.refetchQueries(
+      {
+        ...t,
+        type: t?.refetchType ?? t?.type ?? "active"
+      },
+      e
+    )));
+  }
+  refetchQueries(t, e = {}) {
+    const s = {
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }, i = u.batch(
+      () => this.#t.findAll(t).filter((n) => !n.isDisabled() && !n.isStatic()).map((n) => {
+        let r = n.fetch(void 0, s);
+        return s.throwOnError || (r = r.catch(o)), n.state.fetchStatus === "paused" ? Promise.resolve() : r;
+      })
+    );
+    return Promise.all(i).then(o);
+  }
+  fetchQuery(t) {
+    const e = this.defaultQueryOptions(t);
+    e.retry === void 0 && (e.retry = !1);
+    const s = this.#t.build(this, e);
+    return s.isStaleByTime(
+      f(e.staleTime, s)
+    ) ? s.fetch(e) : Promise.resolve(s.state.data);
+  }
+  prefetchQuery(t) {
+    return this.fetchQuery(t).then(o).catch(o);
+  }
+  fetchInfiniteQuery(t) {
+    return t._type = "infinite", this.fetchQuery(t);
+  }
+  prefetchInfiniteQuery(t) {
+    return this.fetchInfiniteQuery(t).then(o).catch(o);
+  }
+  ensureInfiniteQueryData(t) {
+    return t._type = "infinite", this.ensureQueryData(t);
+  }
+  resumePausedMutations() {
+    return d.isOnline() ? this.#e.resumePausedMutations() : Promise.resolve();
+  }
+  getQueryCache() {
+    return this.#t;
+  }
+  getMutationCache() {
+    return this.#e;
+  }
+  getDefaultOptions() {
+    return this.#s;
+  }
+  setDefaultOptions(t) {
+    this.#s = t;
+  }
+  setQueryDefaults(t, e) {
+    this.#r.set(y(t), {
+      queryKey: t,
+      defaultOptions: e
+    });
+  }
+  getQueryDefaults(t) {
+    const e = [...this.#r.values()], s = {};
+    return e.forEach((i) => {
+      p(t, i.queryKey) && Object.assign(s, i.defaultOptions);
+    }), s;
+  }
+  setMutationDefaults(t, e) {
+    this.#i.set(y(t), {
+      mutationKey: t,
+      defaultOptions: e
+    });
+  }
+  getMutationDefaults(t) {
+    const e = [...this.#i.values()], s = {};
+    return e.forEach((i) => {
+      p(t, i.mutationKey) && Object.assign(s, i.defaultOptions);
+    }), s;
+  }
+  defaultQueryOptions(t) {
+    if (t._defaulted)
+      return t;
+    const e = {
+      ...this.#s.queries,
+      ...this.getQueryDefaults(t.queryKey),
+      ...t,
+      _defaulted: !0
+    };
+    return e.queryHash || (e.queryHash = g(
+      e.queryKey,
+      e
+    )), e.refetchOnReconnect === void 0 && (e.refetchOnReconnect = e.networkMode !== "always"), e.throwOnError === void 0 && (e.throwOnError = !!e.suspense), !e.networkMode && e.persister && (e.networkMode = "offlineFirst"), e.queryFn === w && (e.enabled = !1), e;
+  }
+  defaultMutationOptions(t) {
+    return t?._defaulted ? t : {
+      ...this.#s.mutations,
+      ...t?.mutationKey && this.getMutationDefaults(t.mutationKey),
+      ...t,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    this.#t.clear(), this.#e.clear();
+  }
+};
+const q = new D({
+  defaultOptions: {
+    mutations: {
+      retry: !1
+    },
+    queries: {
+      refetchOnWindowFocus: !1,
+      gcTime: 1e3 * 60 * 60 * 24,
+      // 24 hours
+      staleTime: 60 * 1e3,
+      // 60 seconds
+      retry: !1
+    }
+  }
+});
+export {
+  q as M,
+  D as Q,
+  x as g
+};

package/dist/hooks/useBreadcrumbTranslation.js

@@ -1,22 +1,19 @@
-import { useCallback as s } from "react";
-import { useBasePropsStore as c } from "../stores/BasePropsStore.js";
-const d = () => {
-  const a = c((r) => r.addBreadcrumbTranslation);
-  return s(
-    (r, e) => {
-      const t = r, o = typeof e == "boolean", n = o ? r : e;
-      if (a) {
-        a(
-          { key: t, value: n },
-          //if boolean hide the translation in the breadcrumb
-          o
-        );
-        return;
-      }
+import { useCallback as n } from "react";
+import { useBasePropsStore as s } from "../stores/BasePropsStore.js";
+const l = () => {
+  const a = s((r) => r.addBreadcrumbTranslation);
+  return n(
+    (r, o) => {
+      const e = typeof o == "boolean";
+      a?.(
+        { key: r, value: e ? r : o },
+        //if boolean hide the translation in the breadcrumb
+        e
+      );
     },
     [a]
   );
 };
 export {
-  d as useBreadcrumbTranslation
+  l as useBreadcrumbTranslation
 };

package/dist/hooks/useCustom.js

@@ -1,4 +1,4 @@
-import { u as i } from "../useQuery-DUDyh33-.js";
+import { u as i } from "../useQuery-CUSHkb38.js";
 import { fetchFromCustomApi as n } from "../utils/fetches.js";
 import { universalSelector as p } from "../utils/helper.js";
 const C = ({

package/dist/hooks/useCustomMutation.js

@@ -1,14 +1,14 @@
-import { u as x } from "../useCustomMutation-9VUQ7NbQ.js";
+import { u as x } from "../useCustomMutation-C1aVbjpt.js";
 import "react/jsx-runtime";
 import "react";
-import "../provider/SignalR/SignalRProvider.js";
 import "../stores/BasePropsStore.js";
-import "../ModuleCore-DRMqZO8r.js";
+import "../stores/EnvironmentStore.js";
+import "../utils/defaultSignalRClient.js";
+import "../defaultQueryClient-Cfsorhtn.js";
 import "../utils/fetches.js";
 import "../types/Entities.js";
-import "../api-COabZnyn.js";
+import "../api-CSxWxEZl.js";
 import "../omit-DYPaIq41.js";
-import "../stores/EnvironmentStore.js";
 export {
   x as useCustomMutation
 };

package/dist/hooks/useEntity.js

@@ -1,4 +1,4 @@
-import { u as p } from "../useQuery-DUDyh33-.js";
+import { u as p } from "../useQuery-CUSHkb38.js";
 import { useMemo as g, useCallback as Q } from "react";
 import { useBasePropsStore as m } from "../stores/BasePropsStore.js";
 import { AllEntitiesTypeResultMap as v } from "../types/Entities.js";

package/dist/hooks/useOffline.js

@@ -1,4 +1,4 @@
-import { u as y } from "../IsRestoringProvider-SzKJZczp.js";
+import { u as y } from "../QueryClientProvider-DZI32rjZ.js";
 import { useBasePropsStore as i } from "../stores/BasePropsStore.js";
 import { fetchFromCustomApi as f, getFarmOrgEntities as m, getModuleDependedEntities as d } from "../utils/fetches.js";
 import { getModuleQueryKey as o } from "../utils/helper.js";