@hortiview/modulebase 0.0.1-7.1-beta

package/dist/components/ModuleBase.js

@@ -0,0 +1,30 @@
+import { jsx as r } from "react/jsx-runtime";
+import { useEffect as s } from "react";
+import { Y as u, h as l, O as c, aU as d } from "../chunk-IR6S3I6Y-BmDdD3SP.js";
+import { SignalRProvider as m } from "../provider/SignalR/SignalRProvider.js";
+import { useBasePropsStore as f } from "../stores/BasePropsStore.js";
+import { M as p, a as h } from "../ModuleCore-YCIFN_02.js";
+const v = () => {
+  const e = f((o) => o.currentNavigationPath), t = d();
+  s(() => {
+    e && t(e, { replace: !0 });
+  }, [e, t]);
+}, g = () => (v(), /* @__PURE__ */ r(c, {})), x = ({
+  props: e,
+  routes: t,
+  env: o = void 0,
+  useSignalR: a = !1,
+  queryClient: i = h
+}) => {
+  const n = u([
+    {
+      path: e.basePath,
+      children: t,
+      element: /* @__PURE__ */ r(g, {})
+    }
+  ]);
+  return /* @__PURE__ */ r(p, { props: e, env: o, queryClient: i, children: /* @__PURE__ */ r(m, { enabled: a, children: /* @__PURE__ */ r(l, { router: n }) }) });
+};
+export {
+  x as ModuleBase
+};

package/dist/components/ModuleCore.js

@@ -0,0 +1,10 @@
+import "react/jsx-runtime";
+import { M as a, a as l } from "../ModuleCore-YCIFN_02.js";
+import "react";
+import "../stores/BasePropsStore.js";
+import "../stores/EnvironmentStore.js";
+import "../utils/helper.js";
+export {
+  a as ModuleCore,
+  l as ModuleQueryClient
+};

package/dist/constants.js

@@ -0,0 +1,34 @@
+const a = [
+  "addTranslation",
+  "navigateTo",
+  "modulePermissionToken",
+  "organizationId",
+  "currentLanguageId",
+  "currentNavigationPath"
+], e = 1, t = {
+  /**
+   * The server timed out waiting for the request.
+   */
+  RequestTimeout: 408,
+  /**
+   * The user has sent too many requests in a given amount of time ("rate limiting").
+   */
+  TooManyRequests: 429,
+  /**
+   * The server is not ready to handle the request.
+   */
+  BadGateway: 502,
+  /**
+   * The server is not available.
+   */
+  ServiceUnavailable: 503,
+  /**
+   * The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
+   */
+  GatewayTimeout: 504
+};
+export {
+  a as REQUIRED_PROPS,
+  e as RETRIES,
+  t as RETRY_HTTP_STATUS_CODES
+};

package/dist/hooks/useBreadcrumbTranslation.js

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

package/dist/hooks/useCustom.js

@@ -0,0 +1,19 @@
+import { u as f } from "../useQuery-Bj9k9zik.js";
+import { fetchFromCustomApi as i } from "../utils/fetches.js";
+import { universalSelector as n } from "../utils/helper.js";
+const y = ({
+  endpoint: o,
+  queryKey: t,
+  token: u,
+  selector: r,
+  enabled: m = !0,
+  noAuth: s = !1
+}) => f({
+  queryKey: t,
+  queryFn: () => i(o, u, s),
+  select: (e) => r ? r(e) : n(e),
+  enabled: m
+});
+export {
+  y as useCustom
+};

package/dist/hooks/useCustomMutation.js

@@ -0,0 +1,23 @@
+import { u as n } from "../useMutation-zu8uxBak.js";
+import "react/jsx-runtime";
+import "react";
+import "../provider/SignalR/SignalRProvider.js";
+import "../stores/BasePropsStore.js";
+import "../ModuleCore-YCIFN_02.js";
+import { mutateOnCustomApi as s } from "../utils/fetches.js";
+import "../api-s6E2GJtu.js";
+import "../types/Entities.js";
+import "../omit-C9Qe80rl.js";
+import "../stores/EnvironmentStore.js";
+const d = ({
+  endpoint: t,
+  method: o,
+  token: m,
+  headers: r,
+  noAuth: i
+}) => n({
+  mutationFn: (p, u) => s(u ?? t, p, o, m, r, i)
+});
+export {
+  d as useCustomMutation
+};

package/dist/hooks/useEntity.js

@@ -0,0 +1,57 @@
+import { u as l } from "../useQuery-Bj9k9zik.js";
+import { useMemo as M, useCallback as g } from "react";
+import { useBasePropsStore as p } from "../stores/BasePropsStore.js";
+import { getModuleDependedEntitiesRaw as Q, getModuleDependedEntities as A, getFarmOrgEntities as D } from "../utils/fetches.js";
+import { getModuleQueryKey as m, universalSelector as y } from "../utils/helper.js";
+import { useOption as E, useModuleDependency as q } from "./useOption.js";
+import { AllEntitiesTypeResultMap as k } from "../types/Entities.js";
+const N = (t, e, u = !0, n = !1) => {
+  const a = p((i) => i.moduleId), o = p((i) => i.organizationId), s = t === "ModuleDepended", { getEntityId: d } = K(t), r = F(
+    a,
+    d(e),
+    o,
+    s,
+    n,
+    u
+  );
+  return M(() => {
+    const i = (r.data ?? []).map((c) => {
+      const f = k[e];
+      return s && n ? c : c[f];
+    });
+    return {
+      ...r,
+      data: i
+    };
+  }, [e, r, s, n]);
+}, F = (t, e, u, n, a, o = !0) => {
+  const s = l({
+    queryKey: m([e]),
+    queryFn: () => a ? Q(t ?? "", e ?? "") : A(t ?? "", e ?? ""),
+    enabled: o && n && !!t && !!e && !!u,
+    select: (r) => y(r)
+  }), d = l({
+    queryKey: m([e]),
+    queryFn: () => D(t ?? "", e ?? ""),
+    enabled: o && !n && !!t && !!e && !!u,
+    select: (r) => y(r)
+  });
+  return n ? s : d;
+}, K = (t) => {
+  const { data: e } = E("DataAreaGroup"), { data: u } = E("DataAreaEntity"), { data: n } = q(t === "ModuleDepended");
+  return { getEntityId: g(
+    (o) => {
+      if (t === "ModuleDepended")
+        return n ? n.find((r) => r.registeredEntityName === o)?.id : void 0;
+      if (!e || !u) return;
+      const d = e.find((r) => r.key === t)?.id;
+      if (d)
+        return u.find((r) => r.description === d && r.value === o)?.id;
+    },
+    [t, e, u, n]
+  ) };
+};
+export {
+  N as useEntity,
+  K as useEntityId
+};

package/dist/hooks/useOffline.js

@@ -0,0 +1,45 @@
+import { u as f } from "../QueryClientProvider-Beog9TR7.js";
+import { fetchFromCustomApi as i, getFarmOrgEntities as c, getModuleDependedEntities as m } from "../utils/fetches.js";
+import { getModuleQueryKey as o } from "../utils/helper.js";
+import { useBasePropsStore as p } from "../stores/BasePropsStore.js";
+import { useEntityId as d } from "./useEntity.js";
+const I = () => {
+  const { moduleId: n } = p(), u = f();
+  return {
+    prefetchCustom: async ({
+      queryKey: e,
+      endpoint: t,
+      token: s,
+      noAuth: y = !1
+    }) => {
+      await u.prefetchQuery({
+        queryKey: o(e),
+        queryFn: () => i(t, s, y)
+      });
+    },
+    prefetch: ({
+      queryKey: e,
+      queryFn: t
+    }) => u.prefetchQuery({
+      queryKey: o(e),
+      queryFn: t
+    }),
+    usePrefetchEntity: (e, ...t) => {
+      const { getEntityId: s } = d(e);
+      if (!n) return "Prefetch failed: no moduleId";
+      t.forEach(async (y) => {
+        const r = s(y);
+        r && (e !== "ModuleDepended" ? await u.prefetchQuery({
+          queryKey: o([r]),
+          queryFn: () => c(n, r)
+        }) : await u.prefetchQuery({
+          queryKey: o([r]),
+          queryFn: () => m(n, r)
+        }));
+      });
+    }
+  };
+};
+export {
+  I as useOffline
+};

package/dist/hooks/useOption.js

@@ -0,0 +1,25 @@
+import { u as m } from "../useQuery-Bj9k9zik.js";
+import { g as u } from "../api-s6E2GJtu.js";
+import { useBasePropsStore as n } from "../stores/BasePropsStore.js";
+import { fetchFromModuleApi as c, fetchFromCommonApi as i } from "../utils/fetches.js";
+import { getModuleQueryKey as p, universalSelector as s } from "../utils/helper.js";
+const q = (o) => {
+  const r = n((t) => t.commonOptions), e = u(r, o);
+  return m({
+    queryKey: [o],
+    queryFn: () => e ? Promise.resolve(e) : i(`${o}/dropdown`),
+    select: (t) => s(t)
+  });
+}, F = (o = !0) => {
+  const r = n((e) => e.moduleId);
+  return m({
+    queryKey: p([]),
+    queryFn: () => c(`ModuleDependencies/${r}`),
+    select: (e) => s(e),
+    enabled: o
+  });
+};
+export {
+  F as useModuleDependency,
+  q as useOption
+};

package/dist/hooks/useServiceBus.js

@@ -0,0 +1,25 @@
+import { u as n } from "../useMutation-zu8uxBak.js";
+import { useBasePropsStore as r } from "../stores/BasePropsStore.js";
+const a = ({
+  authenticationKey: i,
+  queue: s,
+  topic: o
+}) => {
+  const e = r((t) => t.serviceBusNotification), c = r((t) => t.throwError);
+  if (!e)
+    throw c?.("serviceBusNotification is not defined", 400);
+  return n({
+    mutationFn: (t) => e(t, i, s, o)
+  });
+}, N = () => {
+  const i = r((o) => o.riseNotification), s = r((o) => o.throwError);
+  if (!i)
+    throw s?.("riseNotification is not defined", 400);
+  return n({
+    mutationFn: (o) => i(o)
+  });
+};
+export {
+  N as useNotification,
+  a as useServiceBus
+};

package/dist/hooks/useSignalRMessages.js

@@ -0,0 +1,13 @@
+import { SignalRModuleContext as i } from "../provider/SignalR/SignalRProvider.js";
+const s = (e) => {
+  i.useSignalREffect(
+    "ModuleApiPushNotification",
+    (...[o]) => {
+      e(o);
+    },
+    [e]
+  );
+};
+export {
+  s as useSignalRMessages
+};

package/dist/hooks/useStores.js

@@ -0,0 +1,14 @@
+import { o as r } from "../omit-C9Qe80rl.js";
+import { useBasePropsStore as e } from "../stores/BasePropsStore.js";
+import { useEnvironmentStore as t } from "../stores/EnvironmentStore.js";
+const i = () => {
+  const o = e();
+  return r(o, "setBaseProps");
+}, m = () => {
+  const o = t();
+  return r(o, "setEnvironment", "addEnvironment");
+};
+export {
+  i as useBaseProps,
+  m as useConfig
+};

package/dist/isRestoring-CLuxJVSA.js

@@ -0,0 +1,281 @@
+import { R as f, r as p, a as u, b as y, d as v, t as b, c as m, n as C, e as g, i as h, f as S } from "./QueryClientProvider-Beog9TR7.js";
+import * as c from "react";
+var D = class extends f {
+  #a;
+  #n;
+  #e;
+  #i;
+  #t;
+  #o;
+  #r;
+  constructor(t) {
+    super(), this.#r = !1, this.#o = t.defaultOptions, this.setOptions(t.options), this.observers = [], this.#i = t.client, this.#e = this.#i.getQueryCache(), this.queryKey = t.queryKey, this.queryHash = t.queryHash, this.#a = q(this.options), this.state = t.state ?? this.#a, this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    return this.#t?.promise;
+  }
+  setOptions(t) {
+    this.options = { ...this.#o, ...t }, this.updateGcTime(this.options.gcTime);
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && this.#e.remove(this);
+  }
+  setData(t, e) {
+    const s = p(this.state.data, t, this.options);
+    return this.#s({
+      data: s,
+      type: "success",
+      dataUpdatedAt: e?.updatedAt,
+      manual: e?.manual
+    }), s;
+  }
+  setState(t, e) {
+    this.#s({ type: "setState", state: t, setStateOptions: e });
+  }
+  cancel(t) {
+    const e = this.#t?.promise;
+    return this.#t?.cancel(t), e ? e.then(u).catch(u) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(this.#a);
+  }
+  isActive() {
+    return this.observers.some(
+      (t) => y(t.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === v || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+  }
+  isStale() {
+    return this.state.isInvalidated ? !0 : this.getObserversCount() > 0 ? this.observers.some(
+      (t) => t.getCurrentResult().isStale
+    ) : this.state.data === void 0;
+  }
+  isStaleByTime(t = 0) {
+    return this.state.isInvalidated || this.state.data === void 0 || !b(this.state.dataUpdatedAt, t);
+  }
+  onFocus() {
+    this.observers.find((e) => e.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: !1 }), this.#t?.continue();
+  }
+  onOnline() {
+    this.observers.find((e) => e.shouldFetchOnReconnect())?.refetch({ cancelRefetch: !1 }), this.#t?.continue();
+  }
+  addObserver(t) {
+    this.observers.includes(t) || (this.observers.push(t), this.clearGcTimeout(), this.#e.notify({ type: "observerAdded", query: this, observer: t }));
+  }
+  removeObserver(t) {
+    this.observers.includes(t) && (this.observers = this.observers.filter((e) => e !== t), this.observers.length || (this.#t && (this.#r ? this.#t.cancel({ revert: !0 }) : this.#t.cancelRetry()), this.scheduleGc()), this.#e.notify({ type: "observerRemoved", query: this, observer: t }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    this.state.isInvalidated || this.#s({ type: "invalidate" });
+  }
+  fetch(t, e) {
+    if (this.state.fetchStatus !== "idle") {
+      if (this.state.data !== void 0 && e?.cancelRefetch)
+        this.cancel({ silent: !0 });
+      else if (this.#t)
+        return this.#t.continueRetry(), this.#t.promise;
+    }
+    if (t && this.setOptions(t), !this.options.queryFn) {
+      const i = this.observers.find((a) => a.options.queryFn);
+      i && this.setOptions(i.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(), r = (i) => {
+      Object.defineProperty(i, "signal", {
+        enumerable: !0,
+        get: () => (this.#r = !0, s.signal)
+      });
+    }, l = () => {
+      const i = g(this.options, e), a = {
+        client: this.#i,
+        queryKey: this.queryKey,
+        meta: this.meta
+      };
+      return r(a), this.#r = !1, this.options.persister ? this.options.persister(
+        i,
+        a,
+        this
+      ) : i(a);
+    }, n = {
+      fetchOptions: e,
+      options: this.options,
+      queryKey: this.queryKey,
+      client: this.#i,
+      state: this.state,
+      fetchFn: l
+    };
+    r(n), this.options.behavior?.onFetch(
+      n,
+      this
+    ), this.#n = this.state, (this.state.fetchStatus === "idle" || this.state.fetchMeta !== n.fetchOptions?.meta) && this.#s({ type: "fetch", meta: n.fetchOptions?.meta });
+    const o = (i) => {
+      h(i) && i.silent || this.#s({
+        type: "error",
+        error: i
+      }), h(i) || (this.#e.config.onError?.(
+        i,
+        this
+      ), this.#e.config.onSettled?.(
+        this.state.data,
+        i,
+        this
+      )), this.scheduleGc();
+    };
+    return this.#t = m({
+      initialPromise: e?.initialPromise,
+      fn: n.fetchFn,
+      abort: s.abort.bind(s),
+      onSuccess: (i) => {
+        if (i === 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}`
+          ), o(new Error(`${this.queryHash} data is undefined`));
+          return;
+        }
+        try {
+          this.setData(i);
+        } catch (a) {
+          o(a);
+          return;
+        }
+        this.#e.config.onSuccess?.(i, this), this.#e.config.onSettled?.(
+          i,
+          this.state.error,
+          this
+        ), this.scheduleGc();
+      },
+      onError: o,
+      onFail: (i, a) => {
+        this.#s({ type: "failed", failureCount: i, error: a });
+      },
+      onPause: () => {
+        this.#s({ type: "pause" });
+      },
+      onContinue: () => {
+        this.#s({ type: "continue" });
+      },
+      retry: n.options.retry,
+      retryDelay: n.options.retryDelay,
+      networkMode: n.options.networkMode,
+      canRun: () => !0
+    }), this.#t.start();
+  }
+  #s(t) {
+    const e = (s) => {
+      switch (t.type) {
+        case "failed":
+          return {
+            ...s,
+            fetchFailureCount: t.failureCount,
+            fetchFailureReason: t.error
+          };
+        case "pause":
+          return {
+            ...s,
+            fetchStatus: "paused"
+          };
+        case "continue":
+          return {
+            ...s,
+            fetchStatus: "fetching"
+          };
+        case "fetch":
+          return {
+            ...s,
+            ...F(s.data, this.options),
+            fetchMeta: t.meta ?? null
+          };
+        case "success":
+          return {
+            ...s,
+            data: t.data,
+            dataUpdateCount: s.dataUpdateCount + 1,
+            dataUpdatedAt: t.dataUpdatedAt ?? Date.now(),
+            error: null,
+            isInvalidated: !1,
+            status: "success",
+            ...!t.manual && {
+              fetchStatus: "idle",
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            }
+          };
+        case "error":
+          const r = t.error;
+          return h(r) && r.revert && this.#n ? { ...this.#n, fetchStatus: "idle" } : {
+            ...s,
+            error: r,
+            errorUpdateCount: s.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: s.fetchFailureCount + 1,
+            fetchFailureReason: r,
+            fetchStatus: "idle",
+            status: "error"
+          };
+        case "invalidate":
+          return {
+            ...s,
+            isInvalidated: !0
+          };
+        case "setState":
+          return {
+            ...s,
+            ...t.state
+          };
+      }
+    };
+    this.state = e(this.state), C.batch(() => {
+      this.observers.forEach((s) => {
+        s.onQueryUpdate();
+      }), this.#e.notify({ query: this, type: "updated", action: t });
+    });
+  }
+};
+function F(t, e) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: S(e.networkMode) ? "fetching" : "paused",
+    ...t === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function q(t) {
+  const e = typeof t.initialData == "function" ? t.initialData() : t.initialData, s = e !== void 0, r = s ? typeof t.initialDataUpdatedAt == "function" ? t.initialDataUpdatedAt() : t.initialDataUpdatedAt : 0;
+  return {
+    data: e,
+    dataUpdateCount: 0,
+    dataUpdatedAt: s ? r ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: s ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var d = c.createContext(!1), R = () => c.useContext(d), U = d.Provider;
+export {
+  U as I,
+  D as Q,
+  F as f,
+  R as u
+};

package/dist/lib/components/ModuleBase.d.ts

@@ -0,0 +1,36 @@
+import { QueryClient } from '@tanstack/react-query';
+import { RouteObject } from 'react-router';
+import { BaseProps } from '../types/BaseProps';
+import { EnvConfig } from '../types/Environment';
+type ModuleBaseProps = {
+    /**
+     * Properties that are passed to the Base component by the host application, {@link BaseProps}
+     */
+    props: BaseProps;
+    /**
+     * Routes that are used in the module, {@link RouteObject}
+     */
+    routes: RouteObject[];
+    /**
+     * @deprecated
+     * Environment configuration that is used to configure the module, {@link EnvConfig}.
+     * New way to pass environment variables is through the base props:
+     * Setup the environment variables in the host application (module edit in the vendor section).
+     * They are then passed to the module within the base props.
+     */
+    env?: EnvConfig;
+    /**
+     * If true, the module will use the SignalR provider to connect to the module API.
+     */
+    useSignalR?: boolean;
+    /**
+     * Query client that is used to provide the module with a query client, {@link QueryClient}.
+     * If not provided, the default query client will be used.
+     */
+    queryClient?: QueryClient;
+};
+/**
+ * Main component of the module. This component is used to create a module with a router and a signalR provider.
+ */
+export declare const ModuleBase: ({ props, routes, env, useSignalR, queryClient, }: ModuleBaseProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/components/ModuleCore.d.ts

@@ -0,0 +1,32 @@
+import { QueryClient } from '@tanstack/react-query';
+import { BaseProps } from '../types/BaseProps';
+import { EnvConfig } from '../types/Environment';
+export declare const ModuleQueryClient: QueryClient;
+type ModuleCoreProps = {
+    /**
+     * Properties that are passed to the Base component by the host application, {@link BaseProps}
+     */
+    props: BaseProps;
+    /**
+     * @deprecated
+     * Environment configuration that is used to configure the module, {@link EnvConfig}.
+     * New way to pass environment variables is through the base props:
+     * Setup the environment variables in the host application (module edit in the vendor section).
+     * They are then passed to the module within the base props.
+     */
+    env?: EnvConfig;
+    /**
+     * Query client that is used to provide the module with a query client, {@link QueryClient}.
+     * If not provided, the default query client will be used.
+     */
+    queryClient?: QueryClient;
+    /**
+     * Children components that are rendered within the module core
+     */
+    children: React.ReactNode;
+};
+/**
+ * Minimal component to create a module with a query client and a signalR provider (to use module api)
+ */
+export declare const ModuleCore: ({ props, env, queryClient, children, }: ModuleCoreProps) => import("react/jsx-runtime").JSX.Element;
+export {};