@hortiview/modulebase 0.0.1

package/README.md

@@ -0,0 +1,8 @@
+# ModuleBase
+The ModuleBase provides a set of components and functions, to get the modulefederation within HortiView to work. 
+To get a more detailed description about the modulefederation-process in HortiView, please [visit the documentation](https://docs.hortiview.com/)
+
+It will handle the navigation/routing, breadcrumb translations, usage of Common- and ModuleAPI and my more.
+
+> This package is is not the ModuleTemplate.<br />
+> It only provides basic and nessecary functions for the implementation of module federation within HortiView

package/dist/QueryClientProvider-DQv4Y3Qu.js

@@ -0,0 +1,707 @@
+import * as C from "react";
+import { jsx as N } from "react/jsx-runtime";
+var R = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, y = typeof window > "u" || "Deno" in globalThis;
+function j() {
+}
+function ne(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function x(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function Q(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function ie(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function I(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function ae(e, t) {
+  const {
+    type: s = "all",
+    exact: n,
+    fetchStatus: i,
+    predicate: a,
+    queryKey: u,
+    stale: r
+  } = e;
+  if (u) {
+    if (n) {
+      if (t.queryHash !== G(u, t.options))
+        return !1;
+    } else if (!E(t.queryKey, u))
+      return !1;
+  }
+  if (s !== "all") {
+    const o = t.isActive();
+    if (s === "active" && !o || s === "inactive" && o)
+      return !1;
+  }
+  return !(typeof r == "boolean" && t.isStale() !== r || i && i !== t.state.fetchStatus || a && !a(t));
+}
+function oe(e, t) {
+  const { exact: s, status: n, predicate: i, mutationKey: a } = e;
+  if (a) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (s) {
+      if (g(t.options.mutationKey) !== g(a))
+        return !1;
+    } else if (!E(t.options.mutationKey, a))
+      return !1;
+  }
+  return !(n && t.state.status !== n || i && !i(t));
+}
+function G(e, t) {
+  return (t?.queryKeyHashFn || g)(e);
+}
+function g(e) {
+  return JSON.stringify(
+    e,
+    (t, s) => w(s) ? Object.keys(s).sort().reduce((n, i) => (n[i] = s[i], n), {}) : s
+  );
+}
+function E(e, t) {
+  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? !Object.keys(t).some((s) => !E(e[s], t[s])) : !1;
+}
+function F(e, t) {
+  if (e === t)
+    return e;
+  const s = A(e) && A(t);
+  if (s || w(e) && w(t)) {
+    const n = s ? e : Object.keys(e), i = n.length, a = s ? t : Object.keys(t), u = a.length, r = s ? [] : {};
+    let o = 0;
+    for (let l = 0; l < u; l++) {
+      const c = s ? l : a[l];
+      (!s && n.includes(c) || s) && e[c] === void 0 && t[c] === void 0 ? (r[c] = void 0, o++) : (r[c] = F(e[c], t[c]), r[c] === e[c] && e[c] !== void 0 && o++);
+    }
+    return i === u && o === i ? e : r;
+  }
+  return t;
+}
+function ue(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const s in e)
+    if (e[s] !== t[s])
+      return !1;
+  return !0;
+}
+function A(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function w(e) {
+  if (!D(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const s = t.prototype;
+  return !(!D(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function D(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function H(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+function z(e, t, s) {
+  if (typeof s.structuralSharing == "function")
+    return s.structuralSharing(e, t);
+  if (s.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return F(e, t);
+      } catch (n) {
+        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}]: ${n}`
+        );
+      }
+    return F(e, t);
+  }
+  return t;
+}
+function ce(e, t, s = 0) {
+  const n = [...e, t];
+  return s && n.length > s ? n.slice(1) : n;
+}
+function he(e, t, s = 0) {
+  const n = [t, ...e];
+  return s && n.length > s ? n.slice(0, -1) : n;
+}
+var O = Symbol();
+function V(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === O && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === O ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+var $ = class extends R {
+  #e;
+  #s;
+  #t;
+  constructor() {
+    super(), this.#t = (e) => {
+      if (!y && window.addEventListener) {
+        const t = () => e();
+        return window.addEventListener("visibilitychange", t, !1), () => {
+          window.removeEventListener("visibilitychange", t);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#s || this.setEventListener(this.#t);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#s?.(), this.#s = void 0);
+  }
+  setEventListener(e) {
+    this.#t = e, this.#s?.(), this.#s = e((t) => {
+      typeof t == "boolean" ? this.setFocused(t) : this.onFocus();
+    });
+  }
+  setFocused(e) {
+    this.#e !== e && (this.#e = e, this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((t) => {
+      t(e);
+    });
+  }
+  isFocused() {
+    return typeof this.#e == "boolean" ? this.#e : globalThis.document?.visibilityState !== "hidden";
+  }
+}, _ = new $(), B = class extends R {
+  #e = !0;
+  #s;
+  #t;
+  constructor() {
+    super(), this.#t = (e) => {
+      if (!y && window.addEventListener) {
+        const t = () => e(!0), s = () => e(!1);
+        return window.addEventListener("online", t, !1), window.addEventListener("offline", s, !1), () => {
+          window.removeEventListener("online", t), window.removeEventListener("offline", s);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#s || this.setEventListener(this.#t);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#s?.(), this.#s = void 0);
+  }
+  setEventListener(e) {
+    this.#t = e, this.#s?.(), this.#s = e(this.setOnline.bind(this));
+  }
+  setOnline(e) {
+    this.#e !== e && (this.#e = e, this.listeners.forEach((s) => {
+      s(e);
+    }));
+  }
+  isOnline() {
+    return this.#e;
+  }
+}, P = new B();
+function J() {
+  let e, t;
+  const s = new Promise((i, a) => {
+    e = i, t = a;
+  });
+  s.status = "pending", s.catch(() => {
+  });
+  function n(i) {
+    Object.assign(s, i), delete s.resolve, delete s.reject;
+  }
+  return s.resolve = (i) => {
+    n({
+      status: "fulfilled",
+      value: i
+    }), e(i);
+  }, s.reject = (i) => {
+    n({
+      status: "rejected",
+      reason: i
+    }), t(i);
+  }, s;
+}
+function W(e) {
+  return Math.min(1e3 * 2 ** e, 3e4);
+}
+function T(e) {
+  return (e ?? "online") === "online" ? P.isOnline() : !0;
+}
+var U = class extends Error {
+  constructor(e) {
+    super("CancelledError"), this.revert = e?.revert, this.silent = e?.silent;
+  }
+};
+function S(e) {
+  return e instanceof U;
+}
+function X(e) {
+  let t = !1, s = 0, n = !1, i;
+  const a = J(), u = (h) => {
+    n || (p(new U(h)), e.abort?.());
+  }, r = () => {
+    t = !0;
+  }, o = () => {
+    t = !1;
+  }, l = () => _.isFocused() && (e.networkMode === "always" || P.isOnline()) && e.canRun(), c = () => T(e.networkMode) && e.canRun(), M = (h) => {
+    n || (n = !0, e.onSuccess?.(h), i?.(), a.resolve(h));
+  }, p = (h) => {
+    n || (n = !0, e.onError?.(h), i?.(), a.reject(h));
+  }, q = () => new Promise((h) => {
+    i = (b) => {
+      (n || l()) && h(b);
+    }, e.onPause?.();
+  }).then(() => {
+    i = void 0, n || e.onContinue?.();
+  }), v = () => {
+    if (n)
+      return;
+    let h;
+    const b = s === 0 ? e.initialPromise : void 0;
+    try {
+      h = b ?? e.fn();
+    } catch (f) {
+      h = Promise.reject(f);
+    }
+    Promise.resolve(h).then(M).catch((f) => {
+      if (n)
+        return;
+      const d = e.retry ?? (y ? 0 : 3), m = e.retryDelay ?? W, K = typeof m == "function" ? m(s, f) : m, L = d === !0 || typeof d == "number" && s < d || typeof d == "function" && d(s, f);
+      if (t || !L) {
+        p(f);
+        return;
+      }
+      s++, e.onFail?.(s, f), H(K).then(() => l() ? void 0 : q()).then(() => {
+        t ? p(f) : v();
+      });
+    });
+  };
+  return {
+    promise: a,
+    cancel: u,
+    continue: () => (i?.(), a),
+    cancelRetry: r,
+    continueRetry: o,
+    canStart: c,
+    start: () => (c() ? v() : q().then(v), a)
+  };
+}
+function Y() {
+  let e = [], t = 0, s = (r) => {
+    r();
+  }, n = (r) => {
+    r();
+  }, i = (r) => setTimeout(r, 0);
+  const a = (r) => {
+    t ? e.push(r) : i(() => {
+      s(r);
+    });
+  }, u = () => {
+    const r = e;
+    e = [], r.length && i(() => {
+      n(() => {
+        r.forEach((o) => {
+          s(o);
+        });
+      });
+    });
+  };
+  return {
+    batch: (r) => {
+      let o;
+      t++;
+      try {
+        o = r();
+      } finally {
+        t--, t || u();
+      }
+      return o;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (r) => (...o) => {
+      a(() => {
+        r(...o);
+      });
+    },
+    schedule: a,
+    /**
+     * 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: (r) => {
+      s = r;
+    },
+    /**
+     * 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: (r) => {
+      n = r;
+    },
+    setScheduler: (r) => {
+      i = r;
+    }
+  };
+}
+var Z = Y(), ee = class {
+  #e;
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), x(this.gcTime) && (this.#e = setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(e) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      e ?? (y ? 1 / 0 : 5 * 60 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    this.#e && (clearTimeout(this.#e), this.#e = void 0);
+  }
+}, le = class extends ee {
+  #e;
+  #s;
+  #t;
+  #i;
+  #r;
+  #o;
+  #a;
+  constructor(e) {
+    super(), this.#a = !1, this.#o = e.defaultOptions, this.setOptions(e.options), this.observers = [], this.#i = e.client, this.#t = this.#i.getQueryCache(), this.queryKey = e.queryKey, this.queryHash = e.queryHash, this.#e = se(this.options), this.state = e.state ?? this.#e, this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    return this.#r?.promise;
+  }
+  setOptions(e) {
+    this.options = { ...this.#o, ...e }, this.updateGcTime(this.options.gcTime);
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && this.#t.remove(this);
+  }
+  setData(e, t) {
+    const s = z(this.state.data, e, this.options);
+    return this.#n({
+      data: s,
+      type: "success",
+      dataUpdatedAt: t?.updatedAt,
+      manual: t?.manual
+    }), s;
+  }
+  setState(e, t) {
+    this.#n({ type: "setState", state: e, setStateOptions: t });
+  }
+  cancel(e) {
+    const t = this.#r?.promise;
+    return this.#r?.cancel(e), t ? t.then(j).catch(j) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(this.#e);
+  }
+  isActive() {
+    return this.observers.some(
+      (e) => I(e.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === O || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+  }
+  isStale() {
+    return this.state.isInvalidated ? !0 : this.getObserversCount() > 0 ? this.observers.some(
+      (e) => e.getCurrentResult().isStale
+    ) : this.state.data === void 0;
+  }
+  isStaleByTime(e = 0) {
+    return this.state.isInvalidated || this.state.data === void 0 || !Q(this.state.dataUpdatedAt, e);
+  }
+  onFocus() {
+    this.observers.find((t) => t.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#r?.continue();
+  }
+  onOnline() {
+    this.observers.find((t) => t.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#r?.continue();
+  }
+  addObserver(e) {
+    this.observers.includes(e) || (this.observers.push(e), this.clearGcTimeout(), this.#t.notify({ type: "observerAdded", query: this, observer: e }));
+  }
+  removeObserver(e) {
+    this.observers.includes(e) && (this.observers = this.observers.filter((t) => t !== e), this.observers.length || (this.#r && (this.#a ? this.#r.cancel({ revert: !0 }) : this.#r.cancelRetry()), this.scheduleGc()), this.#t.notify({ type: "observerRemoved", query: this, observer: e }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    this.state.isInvalidated || this.#n({ type: "invalidate" });
+  }
+  fetch(e, t) {
+    if (this.state.fetchStatus !== "idle") {
+      if (this.state.data !== void 0 && t?.cancelRefetch)
+        this.cancel({ silent: !0 });
+      else if (this.#r)
+        return this.#r.continueRetry(), this.#r.promise;
+    }
+    if (e && this.setOptions(e), !this.options.queryFn) {
+      const r = this.observers.find((o) => o.options.queryFn);
+      r && this.setOptions(r.options);
+    }
+    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error(
+      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"
+    ));
+    const s = new AbortController(), n = (r) => {
+      Object.defineProperty(r, "signal", {
+        enumerable: !0,
+        get: () => (this.#a = !0, s.signal)
+      });
+    }, i = () => {
+      const r = V(this.options, t), o = {
+        client: this.#i,
+        queryKey: this.queryKey,
+        meta: this.meta
+      };
+      return n(o), this.#a = !1, this.options.persister ? this.options.persister(
+        r,
+        o,
+        this
+      ) : r(o);
+    }, a = {
+      fetchOptions: t,
+      options: this.options,
+      queryKey: this.queryKey,
+      client: this.#i,
+      state: this.state,
+      fetchFn: i
+    };
+    n(a), this.options.behavior?.onFetch(
+      a,
+      this
+    ), this.#s = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== a.fetchOptions?.meta) && this.#n({ type: "fetch", meta: a.fetchOptions?.meta });
+    const u = (r) => {
+      S(r) && r.silent || this.#n({
+        type: "error",
+        error: r
+      }), S(r) || (this.#t.config.onError?.(
+        r,
+        this
+      ), this.#t.config.onSettled?.(
+        this.state.data,
+        r,
+        this
+      )), this.scheduleGc();
+    };
+    return this.#r = X({
+      initialPromise: t?.initialPromise,
+      fn: a.fetchFn,
+      abort: s.abort.bind(s),
+      onSuccess: (r) => {
+        if (r === void 0) {
+          process.env.NODE_ENV !== "production" && console.error(
+            `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+          ), u(new Error(`${this.queryHash} data is undefined`));
+          return;
+        }
+        try {
+          this.setData(r);
+        } catch (o) {
+          u(o);
+          return;
+        }
+        this.#t.config.onSuccess?.(r, this), this.#t.config.onSettled?.(
+          r,
+          this.state.error,
+          this
+        ), this.scheduleGc();
+      },
+      onError: u,
+      onFail: (r, o) => {
+        this.#n({ type: "failed", failureCount: r, error: o });
+      },
+      onPause: () => {
+        this.#n({ type: "pause" });
+      },
+      onContinue: () => {
+        this.#n({ type: "continue" });
+      },
+      retry: a.options.retry,
+      retryDelay: a.options.retryDelay,
+      networkMode: a.options.networkMode,
+      canRun: () => !0
+    }), this.#r.start();
+  }
+  #n(e) {
+    const t = (s) => {
+      switch (e.type) {
+        case "failed":
+          return {
+            ...s,
+            fetchFailureCount: e.failureCount,
+            fetchFailureReason: e.error
+          };
+        case "pause":
+          return {
+            ...s,
+            fetchStatus: "paused"
+          };
+        case "continue":
+          return {
+            ...s,
+            fetchStatus: "fetching"
+          };
+        case "fetch":
+          return {
+            ...s,
+            ...te(s.data, this.options),
+            fetchMeta: e.meta ?? null
+          };
+        case "success":
+          return {
+            ...s,
+            data: e.data,
+            dataUpdateCount: s.dataUpdateCount + 1,
+            dataUpdatedAt: e.dataUpdatedAt ?? Date.now(),
+            error: null,
+            isInvalidated: !1,
+            status: "success",
+            ...!e.manual && {
+              fetchStatus: "idle",
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            }
+          };
+        case "error":
+          const n = e.error;
+          return S(n) && n.revert && this.#s ? { ...this.#s, fetchStatus: "idle" } : {
+            ...s,
+            error: n,
+            errorUpdateCount: s.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: s.fetchFailureCount + 1,
+            fetchFailureReason: n,
+            fetchStatus: "idle",
+            status: "error"
+          };
+        case "invalidate":
+          return {
+            ...s,
+            isInvalidated: !0
+          };
+        case "setState":
+          return {
+            ...s,
+            ...e.state
+          };
+      }
+    };
+    this.state = t(this.state), Z.batch(() => {
+      this.observers.forEach((s) => {
+        s.onQueryUpdate();
+      }), this.#t.notify({ query: this, type: "updated", action: e });
+    });
+  }
+};
+function te(e, t) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: T(t.networkMode) ? "fetching" : "paused",
+    ...e === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function se(e) {
+  const t = typeof e.initialData == "function" ? e.initialData() : e.initialData, s = t !== void 0, n = s ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
+  return {
+    data: t,
+    dataUpdateCount: 0,
+    dataUpdatedAt: s ? n ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: s ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var k = C.createContext(
+  void 0
+), fe = (e) => {
+  const t = C.useContext(k);
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, de = ({
+  client: e,
+  children: t
+}) => (C.useEffect(() => (e.mount(), () => {
+  e.unmount();
+}), [e]), /* @__PURE__ */ N(k.Provider, { value: e, children: t }));
+export {
+  le as Q,
+  ee as R,
+  R as S,
+  oe as a,
+  j as b,
+  X as c,
+  he as d,
+  V as e,
+  ce as f,
+  _ as g,
+  G as h,
+  ne as i,
+  g as j,
+  de as k,
+  J as l,
+  ae as m,
+  Z as n,
+  P as o,
+  E as p,
+  I as q,
+  ie as r,
+  O as s,
+  ue as t,
+  y as u,
+  x as v,
+  Q as w,
+  te as x,
+  z as y,
+  fe as z
+};