@hortiview/modulebase 0.0.1

package/dist/components/ModuleBase.d.ts

@@ -0,0 +1,11 @@
+import { QueryClient } from '@tanstack/react-query';
+import { RouteObject } from 'react-router';
+import { BaseProps } from '../types/BaseProps';
+import { EnvConfig } from '../types/Environment';
+export declare const ModuleBase: ({ props, routes, env, useSignalR, queryClient, }: {
+    props: BaseProps;
+    routes: RouteObject[];
+    env?: EnvConfig;
+    useSignalR?: boolean;
+    queryClient?: QueryClient;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/ModuleBase.js

@@ -0,0 +1,691 @@
+import { jsx as g } from "react/jsx-runtime";
+import { S as k, h as N, Q as x, n as u, m as M, R as H, c as K, a as E, b as h, e as B, d as j, f as L, g as U, o as S, r as D, i as G, j as A, p as C, s as V, k as W } from "../QueryClientProvider-DQv4Y3Qu.js";
+import { useState as $, useEffect as q } from "react";
+import { c as z, R as X } from "../chunk-IR6S3I6Y-BvQXS3A3.js";
+import { REQUIRED_PROPS as Y } from "../constants.js";
+import { SignalRProvider as J } from "../provider/SignalR/SignalRProvider.js";
+import { useBasePropsStore as R } from "../stores/BasePropsStore.js";
+import { useEnvironmentStore as F } from "../stores/EnvironmentStore.js";
+var Z = class extends k {
+  constructor(e = {}) {
+    super(), this.config = e, this.#e = /* @__PURE__ */ new Map();
+  }
+  #e;
+  build(e, t, s) {
+    const i = t.queryKey, r = t.queryHash ?? N(i, t);
+    let n = this.get(r);
+    return n || (n = new x({
+      client: e,
+      queryKey: i,
+      queryHash: r,
+      options: e.defaultQueryOptions(t),
+      state: s,
+      defaultOptions: e.getQueryDefaults(i)
+    }), this.add(n)), n;
+  }
+  add(e) {
+    this.#e.has(e.queryHash) || (this.#e.set(e.queryHash, e), this.notify({
+      type: "added",
+      query: e
+    }));
+  }
+  remove(e) {
+    const t = this.#e.get(e.queryHash);
+    t && (e.destroy(), t === e && this.#e.delete(e.queryHash), this.notify({ type: "removed", query: e }));
+  }
+  clear() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        this.remove(e);
+      });
+    });
+  }
+  get(e) {
+    return this.#e.get(e);
+  }
+  getAll() {
+    return [...this.#e.values()];
+  }
+  find(e) {
+    const t = { exact: !0, ...e };
+    return this.getAll().find(
+      (s) => M(t, s)
+    );
+  }
+  findAll(e = {}) {
+    const t = this.getAll();
+    return Object.keys(e).length > 0 ? t.filter((s) => M(e, s)) : t;
+  }
+  notify(e) {
+    u.batch(() => {
+      this.listeners.forEach((t) => {
+        t(e);
+      });
+    });
+  }
+  onFocus() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onOnline();
+      });
+    });
+  }
+}, ee = class extends H {
+  #e;
+  #t;
+  #s;
+  constructor(e) {
+    super(), this.mutationId = e.mutationId, this.#t = e.mutationCache, this.#e = [], this.state = e.state || te(), this.setOptions(e.options), this.scheduleGc();
+  }
+  setOptions(e) {
+    this.options = e, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(e) {
+    this.#e.includes(e) || (this.#e.push(e), this.clearGcTimeout(), this.#t.notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: e
+    }));
+  }
+  removeObserver(e) {
+    this.#e = this.#e.filter((t) => t !== e), this.scheduleGc(), this.#t.notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: e
+    });
+  }
+  optionalRemove() {
+    this.#e.length || (this.state.status === "pending" ? this.scheduleGc() : this.#t.remove(this));
+  }
+  continue() {
+    return this.#s?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(e) {
+    this.#s = K({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(e) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (i, r) => {
+        this.#i({ type: "failed", failureCount: i, error: r });
+      },
+      onPause: () => {
+        this.#i({ type: "pause" });
+      },
+      onContinue: () => {
+        this.#i({ type: "continue" });
+      },
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => this.#t.canRun(this)
+    });
+    const t = this.state.status === "pending", s = !this.#s.canStart();
+    try {
+      if (!t) {
+        this.#i({ type: "pending", variables: e, isPaused: s }), await this.#t.config.onMutate?.(
+          e,
+          this
+        );
+        const r = await this.options.onMutate?.(e);
+        r !== this.state.context && this.#i({
+          type: "pending",
+          context: r,
+          variables: e,
+          isPaused: s
+        });
+      }
+      const i = await this.#s.start();
+      return await this.#t.config.onSuccess?.(
+        i,
+        e,
+        this.state.context,
+        this
+      ), await this.options.onSuccess?.(i, e, this.state.context), await this.#t.config.onSettled?.(
+        i,
+        null,
+        this.state.variables,
+        this.state.context,
+        this
+      ), await this.options.onSettled?.(i, null, e, this.state.context), this.#i({ type: "success", data: i }), i;
+    } catch (i) {
+      try {
+        throw await this.#t.config.onError?.(
+          i,
+          e,
+          this.state.context,
+          this
+        ), await this.options.onError?.(
+          i,
+          e,
+          this.state.context
+        ), await this.#t.config.onSettled?.(
+          void 0,
+          i,
+          this.state.variables,
+          this.state.context,
+          this
+        ), await this.options.onSettled?.(
+          void 0,
+          i,
+          e,
+          this.state.context
+        ), i;
+      } finally {
+        this.#i({ type: "error", error: i });
+      }
+    } finally {
+      this.#t.runNext(this);
+    }
+  }
+  #i(e) {
+    const t = (s) => {
+      switch (e.type) {
+        case "failed":
+          return {
+            ...s,
+            failureCount: e.failureCount,
+            failureReason: e.error
+          };
+        case "pause":
+          return {
+            ...s,
+            isPaused: !0
+          };
+        case "continue":
+          return {
+            ...s,
+            isPaused: !1
+          };
+        case "pending":
+          return {
+            ...s,
+            context: e.context,
+            data: void 0,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: e.isPaused,
+            status: "pending",
+            variables: e.variables,
+            submittedAt: Date.now()
+          };
+        case "success":
+          return {
+            ...s,
+            data: e.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: "success",
+            isPaused: !1
+          };
+        case "error":
+          return {
+            ...s,
+            data: void 0,
+            error: e.error,
+            failureCount: s.failureCount + 1,
+            failureReason: e.error,
+            isPaused: !1,
+            status: "error"
+          };
+      }
+    };
+    this.state = t(this.state), u.batch(() => {
+      this.#e.forEach((s) => {
+        s.onMutationUpdate(e);
+      }), this.#t.notify({
+        mutation: this,
+        type: "updated",
+        action: e
+      });
+    });
+  }
+};
+function te() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var se = class extends k {
+  constructor(e = {}) {
+    super(), this.config = e, this.#e = /* @__PURE__ */ new Set(), this.#t = /* @__PURE__ */ new Map(), this.#s = 0;
+  }
+  #e;
+  #t;
+  #s;
+  build(e, t, s) {
+    const i = new ee({
+      mutationCache: this,
+      mutationId: ++this.#s,
+      options: e.defaultMutationOptions(t),
+      state: s
+    });
+    return this.add(i), i;
+  }
+  add(e) {
+    this.#e.add(e);
+    const t = O(e);
+    if (typeof t == "string") {
+      const s = this.#t.get(t);
+      s ? s.push(e) : this.#t.set(t, [e]);
+    }
+    this.notify({ type: "added", mutation: e });
+  }
+  remove(e) {
+    if (this.#e.delete(e)) {
+      const t = O(e);
+      if (typeof t == "string") {
+        const s = this.#t.get(t);
+        if (s)
+          if (s.length > 1) {
+            const i = s.indexOf(e);
+            i !== -1 && s.splice(i, 1);
+          } else s[0] === e && this.#t.delete(t);
+      }
+    }
+    this.notify({ type: "removed", mutation: e });
+  }
+  canRun(e) {
+    const t = O(e);
+    if (typeof t == "string") {
+      const i = this.#t.get(t)?.find(
+        (r) => r.state.status === "pending"
+      );
+      return !i || i === e;
+    } else
+      return !0;
+  }
+  runNext(e) {
+    const t = O(e);
+    return typeof t == "string" ? this.#t.get(t)?.find((i) => i !== e && i.state.isPaused)?.continue() ?? Promise.resolve() : Promise.resolve();
+  }
+  clear() {
+    u.batch(() => {
+      this.#e.forEach((e) => {
+        this.notify({ type: "removed", mutation: e });
+      }), this.#e.clear(), this.#t.clear();
+    });
+  }
+  getAll() {
+    return Array.from(this.#e);
+  }
+  find(e) {
+    const t = { exact: !0, ...e };
+    return this.getAll().find(
+      (s) => E(t, s)
+    );
+  }
+  findAll(e = {}) {
+    return this.getAll().filter((t) => E(e, t));
+  }
+  notify(e) {
+    u.batch(() => {
+      this.listeners.forEach((t) => {
+        t(e);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const e = this.getAll().filter((t) => t.state.isPaused);
+    return u.batch(
+      () => Promise.all(
+        e.map((t) => t.continue().catch(h))
+      )
+    );
+  }
+};
+function O(e) {
+  return e.options.scope?.id;
+}
+function T(e) {
+  return {
+    onFetch: (t, s) => {
+      const i = t.options, r = t.fetchOptions?.meta?.fetchMore?.direction, n = t.state.data?.pages || [], d = t.state.data?.pageParams || [];
+      let c = { pages: [], pageParams: [] }, f = 0;
+      const P = async () => {
+        let y = !1;
+        const w = (o) => {
+          Object.defineProperty(o, "signal", {
+            enumerable: !0,
+            get: () => (t.signal.aborted ? y = !0 : t.signal.addEventListener("abort", () => {
+              y = !0;
+            }), t.signal)
+          });
+        }, a = B(t.options, t.fetchOptions), p = async (o, l, m) => {
+          if (y)
+            return Promise.reject();
+          if (l == null && o.pages.length)
+            return Promise.resolve(o);
+          const v = {
+            client: t.client,
+            queryKey: t.queryKey,
+            pageParam: l,
+            direction: m ? "backward" : "forward",
+            meta: t.options.meta
+          };
+          w(v);
+          const _ = await a(
+            v
+          ), { maxPages: b } = t.options, Q = m ? j : L;
+          return {
+            pages: Q(o.pages, _, b),
+            pageParams: Q(o.pageParams, l, b)
+          };
+        };
+        if (r && n.length) {
+          const o = r === "backward", l = o ? ie : I, m = {
+            pages: n,
+            pageParams: d
+          }, v = l(i, m);
+          c = await p(m, v, o);
+        } else {
+          const o = e ?? n.length;
+          do {
+            const l = f === 0 ? d[0] ?? i.initialPageParam : I(i, c);
+            if (f > 0 && l == null)
+              break;
+            c = await p(c, l), f++;
+          } while (f < o);
+        }
+        return c;
+      };
+      t.options.persister ? t.fetchFn = () => t.options.persister?.(
+        P,
+        {
+          client: t.client,
+          queryKey: t.queryKey,
+          meta: t.options.meta,
+          signal: t.signal
+        },
+        s
+      ) : t.fetchFn = P;
+    }
+  };
+}
+function I(e, { pages: t, pageParams: s }) {
+  const i = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(
+    t[i],
+    t,
+    s[i],
+    s
+  ) : void 0;
+}
+function ie(e, { pages: t, pageParams: s }) {
+  return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, s[0], s) : void 0;
+}
+var re = class {
+  #e;
+  #t;
+  #s;
+  #i;
+  #n;
+  #r;
+  #a;
+  #u;
+  constructor(e = {}) {
+    this.#e = e.queryCache || new Z(), this.#t = e.mutationCache || new se(), this.#s = e.defaultOptions || {}, this.#i = /* @__PURE__ */ new Map(), this.#n = /* @__PURE__ */ new Map(), this.#r = 0;
+  }
+  mount() {
+    this.#r++, this.#r === 1 && (this.#a = U.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), this.#e.onFocus());
+    }), this.#u = S.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), this.#e.onOnline());
+    }));
+  }
+  unmount() {
+    this.#r--, this.#r === 0 && (this.#a?.(), this.#a = void 0, this.#u?.(), this.#u = void 0);
+  }
+  isFetching(e) {
+    return this.#e.findAll({ ...e, fetchStatus: "fetching" }).length;
+  }
+  isMutating(e) {
+    return this.#t.findAll({ ...e, status: "pending" }).length;
+  }
+  getQueryData(e) {
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return this.#e.get(t.queryHash)?.state.data;
+  }
+  ensureQueryData(e) {
+    const t = this.defaultQueryOptions(e), s = this.#e.build(this, t), i = s.state.data;
+    return i === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && s.isStaleByTime(D(t.staleTime, s)) && this.prefetchQuery(t), Promise.resolve(i));
+  }
+  getQueriesData(e) {
+    return this.#e.findAll(e).map(({ queryKey: t, state: s }) => {
+      const i = s.data;
+      return [t, i];
+    });
+  }
+  setQueryData(e, t, s) {
+    const i = this.defaultQueryOptions({ queryKey: e }), n = this.#e.get(
+      i.queryHash
+    )?.state.data, d = G(t, n);
+    if (d !== void 0)
+      return this.#e.build(this, i).setData(d, { ...s, manual: !0 });
+  }
+  setQueriesData(e, t, s) {
+    return u.batch(
+      () => this.#e.findAll(e).map(({ queryKey: i }) => [
+        i,
+        this.setQueryData(i, t, s)
+      ])
+    );
+  }
+  getQueryState(e) {
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return this.#e.get(
+      t.queryHash
+    )?.state;
+  }
+  removeQueries(e) {
+    const t = this.#e;
+    u.batch(() => {
+      t.findAll(e).forEach((s) => {
+        t.remove(s);
+      });
+    });
+  }
+  resetQueries(e, t) {
+    const s = this.#e, i = {
+      type: "active",
+      ...e
+    };
+    return u.batch(() => (s.findAll(e).forEach((r) => {
+      r.reset();
+    }), this.refetchQueries(i, t)));
+  }
+  cancelQueries(e, t = {}) {
+    const s = { revert: !0, ...t }, i = u.batch(
+      () => this.#e.findAll(e).map((r) => r.cancel(s))
+    );
+    return Promise.all(i).then(h).catch(h);
+  }
+  invalidateQueries(e, t = {}) {
+    return u.batch(() => {
+      if (this.#e.findAll(e).forEach((i) => {
+        i.invalidate();
+      }), e?.refetchType === "none")
+        return Promise.resolve();
+      const s = {
+        ...e,
+        type: e?.refetchType ?? e?.type ?? "active"
+      };
+      return this.refetchQueries(s, t);
+    });
+  }
+  refetchQueries(e, t = {}) {
+    const s = {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }, i = u.batch(
+      () => this.#e.findAll(e).filter((r) => !r.isDisabled()).map((r) => {
+        let n = r.fetch(void 0, s);
+        return s.throwOnError || (n = n.catch(h)), r.state.fetchStatus === "paused" ? Promise.resolve() : n;
+      })
+    );
+    return Promise.all(i).then(h);
+  }
+  fetchQuery(e) {
+    const t = this.defaultQueryOptions(e);
+    t.retry === void 0 && (t.retry = !1);
+    const s = this.#e.build(this, t);
+    return s.isStaleByTime(
+      D(t.staleTime, s)
+    ) ? s.fetch(t) : Promise.resolve(s.state.data);
+  }
+  prefetchQuery(e) {
+    return this.fetchQuery(e).then(h).catch(h);
+  }
+  fetchInfiniteQuery(e) {
+    return e.behavior = T(e.pages), this.fetchQuery(e);
+  }
+  prefetchInfiniteQuery(e) {
+    return this.fetchInfiniteQuery(e).then(h).catch(h);
+  }
+  ensureInfiniteQueryData(e) {
+    return e.behavior = T(e.pages), this.ensureQueryData(e);
+  }
+  resumePausedMutations() {
+    return S.isOnline() ? this.#t.resumePausedMutations() : Promise.resolve();
+  }
+  getQueryCache() {
+    return this.#e;
+  }
+  getMutationCache() {
+    return this.#t;
+  }
+  getDefaultOptions() {
+    return this.#s;
+  }
+  setDefaultOptions(e) {
+    this.#s = e;
+  }
+  setQueryDefaults(e, t) {
+    this.#i.set(A(e), {
+      queryKey: e,
+      defaultOptions: t
+    });
+  }
+  getQueryDefaults(e) {
+    const t = [...this.#i.values()], s = {};
+    return t.forEach((i) => {
+      C(e, i.queryKey) && Object.assign(s, i.defaultOptions);
+    }), s;
+  }
+  setMutationDefaults(e, t) {
+    this.#n.set(A(e), {
+      mutationKey: e,
+      defaultOptions: t
+    });
+  }
+  getMutationDefaults(e) {
+    const t = [...this.#n.values()];
+    let s = {};
+    return t.forEach((i) => {
+      C(e, i.mutationKey) && (s = { ...s, ...i.defaultOptions });
+    }), s;
+  }
+  defaultQueryOptions(e) {
+    if (e._defaulted)
+      return e;
+    const t = {
+      ...this.#s.queries,
+      ...this.getQueryDefaults(e.queryKey),
+      ...e,
+      _defaulted: !0
+    };
+    return t.queryHash || (t.queryHash = N(
+      t.queryKey,
+      t
+    )), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === V && (t.enabled = !1), t;
+  }
+  defaultMutationOptions(e) {
+    return e?._defaulted ? e : {
+      ...this.#s.mutations,
+      ...e?.mutationKey && this.getMutationDefaults(e.mutationKey),
+      ...e,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    this.#e.clear(), this.#t.clear();
+  }
+};
+const ne = new re({
+  defaultOptions: {
+    mutations: {
+      retry: !1
+    },
+    queries: {
+      refetchOnWindowFocus: !1,
+      gcTime: 1e3 * 60 * 60 * 24,
+      // 24 hours
+      staleTime: 60 * 1e3,
+      // 60 seconds
+      retry: !1
+    }
+  }
+}), ge = ({
+  props: e,
+  routes: t,
+  env: s = void 0,
+  useSignalR: i = !1,
+  queryClient: r = ne
+}) => {
+  const n = R((a) => a.setBaseProps), d = R((a) => a.modulePermissionToken), c = F((a) => a.setEnvironment), f = F((a) => a.addEnvironment), [P, y] = $(!1);
+  q(() => {
+    const a = oe();
+    if (y(!a), a && c(a), !s) return;
+    console.log(s);
+    const p = s[a?.ENVIRONMENT];
+    p && f(p);
+  }, [f, s, c]), q(() => {
+    y(!ae(e)), n(e);
+  }, [
+    e.currentLanguage,
+    e.currentLanguageId,
+    e.modulePermissionToken,
+    e.organizationId,
+    e.currentNavigationPath,
+    e.sourcePath
+  ]);
+  const w = z([
+    {
+      path: e.basePath,
+      children: t
+    }
+  ]);
+  return P ? /* @__PURE__ */ g("div", { children: "TODO: Show fancy error" }) : d ? /* @__PURE__ */ g(W, { client: r, children: /* @__PURE__ */ g(J, { enabled: i, children: /* @__PURE__ */ g(X, { router: w }) }) }) : /* @__PURE__ */ g("div", { children: "TODO: Show fancy Loadingspinner" });
+}, ae = (e) => Y.every((t) => ue(t, e)), ue = (e, t) => {
+  if (!t[e]) {
+    if (t.throwError)
+      return t.throwError(`Missing required prop: ${e}`, 404), !1;
+    throw new Error(`Missing required prop: ${e}`);
+  }
+  return !0;
+}, oe = () => {
+  const e = window.__env__;
+  if (e && e.COMMON_API && e.MODULE_AUTH_API && e.API_PREFIX && e.ENVIRONMENT)
+    return e;
+};
+export {
+  ge as ModuleBase
+};