@hortiview/modulebase 0.0.1 → 0.0.17-beta

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 {};

package/dist/{constants.d.ts → lib/constants.d.ts}

@@ -1,4 +1,4 @@
-import { BaseProps } from './main';
+import { BaseProps } from './types/BaseProps';
 export declare const REQUIRED_PROPS: (keyof BaseProps)[];
 export declare const RETRIES = 1;
 export declare const RETRY_HTTP_STATUS_CODES: {

package/dist/{hooks → lib/hooks}/useBreadcrumbTranslation.d.ts

@@ -1 +1 @@
-export declare const useBreadcrumbTranslation: () => (key: string, value: string) => void;
+export declare const useBreadcrumbTranslation: () => (key: string, value: string | false) => void;

package/dist/lib/hooks/useCustom.d.ts

@@ -0,0 +1,8 @@
+export declare const useCustom: <T>({ endpoint, queryKey, token, selector, enabled, noAuth }: {
+    endpoint: string;
+    queryKey: (string | undefined)[];
+    token?: string;
+    selector?: (data: any) => T;
+    enabled?: boolean;
+    noAuth?: boolean;
+}) => import('@tanstack/react-query').UseQueryResult<T, Error>;

package/dist/lib/hooks/useCustomMutation.d.ts

@@ -0,0 +1,9 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { BaseResponse, httpMethod } from '../types/Requests';
+export declare const useCustomMutation: <Input, Output>({ endpoint, method, token, headers, noAuth }: {
+    endpoint: string;
+    method: Omit<httpMethod, "GET">;
+    token?: string;
+    headers?: Headers;
+    noAuth?: boolean;
+}) => UseMutationResult<BaseResponse<Output>, Error, Input, unknown>;

package/dist/{hooks → lib/hooks}/useEntity.d.ts

@@ -1,32 +1,6 @@
-import { Block, BlockPlantLayout, Farm, FarmOrgEntity, Field, ModuleEntity, Season } from '../types/ModuleApi';
-type HortiviewDataAreaGroup = 'FarmOrganization' | 'FarmMember';
-type ModuleDataAreaGroup = 'ModuleDepended';
-type FarmOrganizationEntities = 'farms' | 'fields' | 'zones' | 'irrigation_stations' | 'farm_organizations' | 'alert_rules';
-type FarmMemberEntities = 'farm_members';
-type ModuleDependendEntities = 'Season' | 'BlockPlantLayout' | (string & {});
-type HortiviewDataAreaEntity<T extends HortiviewDataAreaGroup | ModuleDataAreaGroup> = T extends 'FarmOrganization' ? FarmOrganizationEntities : T extends 'FarmMember' ? FarmMemberEntities : T extends 'ModuleDepended' ? ModuleDependendEntities : never;
-type ResultMap<T extends FarmMemberEntities | FarmOrganizationEntities | ModuleDependendEntities> = T extends 'zones' ? Block : T extends 'fields' ? Field : T extends 'farms' ? Farm : T extends 'irrigation_stations' ? {
-    id: string;
-} : T extends 'farm_organizations' ? {
-    id: string;
-} : T extends 'alert_rules' ? {
-    id: string;
-} : T extends 'Season' ? Season : T extends 'BlockPlantLayout' ? BlockPlantLayout : never;
-export declare const FarmOrgEntitiesTypeResultMap: Record<FarmOrganizationEntities, string>;
-export declare const FarmMemberEntitiesTypeResultMap: Record<FarmMemberEntities, string>;
-export declare const ModuleDependedEntityTypeResultMap: Record<ModuleDependendEntities, string>;
-export declare const AllEntitiesTypeResultMap: {
-    Season: string;
-    BlockPlantLayout: string;
-    farm_members: string;
-    farms: string;
-    fields: string;
-    zones: string;
-    irrigation_stations: string;
-    farm_organizations: string;
-    alert_rules: string;
-};
-export declare const useEntity: <K extends HortiviewDataAreaGroup | ModuleDataAreaGroup, E extends HortiviewDataAreaEntity<K>>(group: K, entity: E) => {
+import { FarmOrgEntity, ModuleEntity } from '../types/ModuleApi';
+import { HortiviewDataAreaEntity, HortiviewDataAreaGroup, ModuleDataAreaGroup, ResultMap } from '../types/Entities';
+export declare const useEntity: <K extends HortiviewDataAreaGroup | ModuleDataAreaGroup, E extends HortiviewDataAreaEntity<K>>(group: K, entity: E, enabled?: boolean, shouldGetRawData?: boolean) => {
     data: ResultMap<E>[];
     error: Error;
     isError: true;
@@ -183,4 +157,6 @@ export declare const useEntity: <K extends HortiviewDataAreaGroup | ModuleDataAr
     fetchStatus: import('@tanstack/query-core').FetchStatus;
     promise: Promise<FarmOrgEntity[] | ModuleEntity[]>;
 };
-export {};
+export declare const useEntityId: (group: HortiviewDataAreaGroup | ModuleDataAreaGroup) => {
+    getEntityId: (entity: HortiviewDataAreaEntity<typeof group>) => string | undefined;
+};

package/dist/lib/hooks/useOffline.d.ts

@@ -0,0 +1,15 @@
+import { HortiviewDataAreaEntity, HortiviewDataAreaGroup, ModuleDataAreaGroup } from '../types/Entities';
+export declare const useOffline: () => {
+    prefetchCustom: <T>({ queryKey, endpoint, token, noAuth, }: {
+        queryKey: (string | undefined)[];
+        endpoint: string;
+        token?: string;
+        noAuth?: boolean;
+        selector?: (data: any) => T;
+    }) => Promise<void>;
+    prefetch: <T>({ queryKey, queryFn, }: {
+        queryKey: (string | undefined)[];
+        queryFn: () => Promise<T>;
+    }) => Promise<void>;
+    usePrefetchEntity: <K extends HortiviewDataAreaGroup | ModuleDataAreaGroup, E extends HortiviewDataAreaEntity<K>>(group: K, ...entities: E[]) => "Prefetch failed: no moduleId" | undefined;
+};

package/dist/{hooks → lib/hooks}/useOption.d.ts

@@ -14,4 +14,4 @@ import { RegisterOption } from '../types/ModuleApi';
  * or fetches it from the API. The result is then processed by a universal selector.
  */
 export declare const useOption: (dropdown: keyof typeof CommonOptionType) => UseQueryResult<CommonOption[], Error>;
-export declare const useModuleDependency: () => UseQueryResult<RegisterOption[], Error>;
+export declare const useModuleDependency: (enabled?: boolean) => UseQueryResult<RegisterOption[], Error>;

package/dist/lib/hooks/useServiceBus.d.ts

@@ -0,0 +1,19 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { BaseResponse } from '../types/Requests';
+import { AlertServiceBusMessage } from '../types/ServiceBus';
+/**
+ *
+ * @param authenticationKey SASToken, that will be provided by the vendor portal of HortiView
+ * @param queue url of the service bus queue
+ * @param topic topic of the service bus, where the message will be sent to
+ * @deprecated use useNotification instead
+ */
+export declare const useServiceBus: ({ authenticationKey, queue, topic, }: {
+    authenticationKey: string;
+    queue: string;
+    topic: string;
+}) => UseMutationResult<BaseResponse<unknown>, Error, AlertServiceBusMessage, unknown>;
+/**
+ * create a notification in the service bus
+ */
+export declare const useNotification: () => UseMutationResult<BaseResponse<unknown>, Error, AlertServiceBusMessage, unknown>;

package/dist/lib/hooks/useStores.d.ts

@@ -0,0 +1,38 @@
+export declare const useBaseProps: () => Pick<import('../main').DeprecatedBaseProps & {
+    isOnline?: boolean;
+    modulePermissionToken?: string;
+    moduleId?: string;
+    organizationId?: string;
+    basePath?: string;
+    currentNavigationPath?: string;
+    sourcePath?: string | null;
+    currentLanguage?: string;
+    currentLanguageId?: string;
+    alertRules?: string;
+    commonOptions?: import('../main').AllDropdownsData<import('../main').CommonOption>["items"];
+    riseNotification?: (message: import('../main').AlertServiceBusMessage) => Promise<unknown>;
+    navigateInHortiview?: (path: string) => void;
+    addBreadcrumbTranslation?: (translation: {
+        key: string;
+        value: string;
+    }, hide?: boolean) => void;
+    showSnackbar?: (message: string, icon?: string) => void;
+    showMessage?: (message: import('../main').SystemMessage) => void;
+    pendingActions?: import('../main').ActionItem[];
+    resolveAction?: (key: string, result?: string) => void;
+    addAction?: (action?: (...args: unknown[]) => void | unknown | Promise<unknown>, actionInfo?: import('../main').ActionItem["actionInfo"], key?: string, ...args: unknown[]) => void;
+    addAction2?: (actionInfo: import('../main').ActionItem["actionInfo"], key?: string) => void;
+    getActions?: () => import('../main').ActionItem[];
+    getActionByKey?: (key: string) => import('../main').ActionItem | undefined;
+    logEvent?: (event: import('../main').AppInsightsEvent, customProperties?: import('../main').AppInsightsProperties) => void;
+    logError?: (exception: import('../main').AppInsightsException) => void;
+    throwError?: (message: string, code: number) => void;
+    environmentVariables?: import('../main').EnvironmentVariable[];
+} & {
+    setBaseProps: (props: import('../main').BaseProps) => void;
+}, keyof import('../main').DeprecatedBaseProps | "isOnline" | "modulePermissionToken" | "moduleId" | "organizationId" | "basePath" | "currentNavigationPath" | "sourcePath" | "currentLanguage" | "currentLanguageId" | "alertRules" | "commonOptions" | "riseNotification" | "navigateInHortiview" | "addBreadcrumbTranslation" | "showSnackbar" | "showMessage" | "pendingActions" | "resolveAction" | "addAction" | "addAction2" | "getActions" | "getActionByKey" | "logEvent" | "logError" | "throwError" | "environmentVariables">;
+export declare const useConfig: () => Pick<{
+    environment: import('../main').HortiViewEnvironments;
+    setEnvironment: (environment: import('../main').HortiViewEnvironments) => void;
+    addEnvironment: (customEnv: import('../main').CustomEnv) => void;
+}, "environment">;

package/dist/lib/main.d.ts

@@ -0,0 +1,27 @@
+export { ModuleBase } from './components/ModuleBase';
+export { ModuleCore } from './components/ModuleCore';
+export type * from './types/AppInsights';
+export type * from './types/BaseProps';
+export type * from './types/CommonOptions';
+export type * from './types/Deprecated';
+export type * from './types/Environment';
+export type * from './types/EnvironmentVariable';
+export type * from './types/ModuleApi';
+export type * from './types/Requests';
+export type * from './types/ServiceBus';
+export type * from './types/SystemMessage';
+export type * from './types/ActionStorage';
+export { useBreadcrumbTranslation } from './hooks/useBreadcrumbTranslation';
+export { useOffline } from './hooks/useOffline';
+export { useSignalRMessages } from './hooks/useSignalRMessages';
+export * from './module-router';
+export { useNavigate } from './module-router';
+export { useBaseProps, useConfig } from './hooks/useStores';
+export { useCustom } from './hooks/useCustom';
+export { useCustomMutation } from './hooks/useCustomMutation';
+export { useEntity } from './hooks/useEntity';
+export { useOption } from './hooks/useOption';
+export { useNotification, useServiceBus } from './hooks/useServiceBus';
+export { QueryClient, useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+export { mutateOnCustomApi } from './utils/fetches';
+export * from './utils/helper';

package/dist/lib/module-router.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @returns A function to navigate to a specific path
+ */
+declare const useNavigate: () => (path: string) => void;
+export * from 'react-router';
+export { useNavigate };

package/dist/{stores → lib/stores}/EnvironmentStore.d.ts

@@ -1,6 +1,6 @@
 import { CustomEnv, HortiViewEnvironments } from '../types/Environment';
 type EnvironmentStore = {
-    environment?: HortiViewEnvironments;
+    environment: HortiViewEnvironments;
     setEnvironment: (environment: HortiViewEnvironments) => void;
     addEnvironment: (customEnv: CustomEnv) => void;
 };

package/dist/lib/types/ActionStorage.d.ts

@@ -0,0 +1,16 @@
+export declare enum ActionState {
+    PENDING = "PENDING",
+    SUCCESS = "RESOLVED",
+    ERROR = "REJECTED"
+}
+export type ActionItem = {
+    action: (...args: unknown[]) => void | unknown | Promise<unknown>;
+    actionInfo: {
+        functionName: string;
+        args: unknown[];
+    };
+    dateAdded: string;
+    state: ActionState;
+    key: string;
+    result: string;
+};

package/dist/{types → lib/types}/BaseProps.d.ts

@@ -1,6 +1,9 @@
+import { ActionItem } from './ActionStorage';
 import { AppInsightsEvent, AppInsightsException, AppInsightsProperties } from './AppInsights';
 import { AllDropdownsData, CommonOption } from './CommonOptions';
 import { DeprecatedBaseProps } from './Deprecated';
+import { EnvironmentVariable } from './EnvironmentVariable';
+import { AlertServiceBusMessage } from './ServiceBus';
 import { SystemMessage } from './SystemMessage';
 /**
  * Properties that are passed to the Base component by the host application
@@ -15,6 +18,7 @@ import { SystemMessage } from './SystemMessage';
  * @param currentNavigationPath current path of the route, that is changed, when the host application navigates
  */
 export type BaseProps = DeprecatedBaseProps & {
+    isOnline?: boolean;
     modulePermissionToken?: string;
     moduleId?: string;
     organizationId?: string;
@@ -24,15 +28,23 @@ export type BaseProps = DeprecatedBaseProps & {
     currentLanguage?: string;
     currentLanguageId?: string;
     alertRules?: string;
-    commonOptions?: AllDropdownsData<CommonOption>["items"];
+    commonOptions?: AllDropdownsData<CommonOption>['items'];
+    riseNotification?: (message: AlertServiceBusMessage) => Promise<unknown>;
     navigateInHortiview?: (path: string) => void;
     addBreadcrumbTranslation?: (translation: {
         key: string;
         value: string;
-    }) => void;
+    }, hide?: boolean) => void;
     showSnackbar?: (message: string, icon?: string) => void;
     showMessage?: (message: SystemMessage) => void;
+    pendingActions?: ActionItem[];
+    resolveAction?: (key: string, result?: string) => void;
+    addAction?: (action?: (...args: unknown[]) => void | unknown | Promise<unknown>, actionInfo?: ActionItem['actionInfo'], key?: string, ...args: unknown[]) => void;
+    addAction2?: (actionInfo: ActionItem['actionInfo'], key?: string) => void;
+    getActions?: () => ActionItem[];
+    getActionByKey?: (key: string) => ActionItem | undefined;
     logEvent?: (event: AppInsightsEvent, customProperties?: AppInsightsProperties) => void;
     logError?: (exception: AppInsightsException) => void;
     throwError?: (message: string, code: number) => void;
+    environmentVariables?: EnvironmentVariable[];
 };

package/dist/{types → lib/types}/Deprecated.d.ts

@@ -1,3 +1,4 @@
+import { AlertServiceBusMessage } from './ServiceBus';
 import { SystemMessage } from './SystemMessage';
 /**
  * @deprecated should not be used anymore, will be removed in the near future (max 2 months)
@@ -21,6 +22,11 @@ export type DeprecatedBaseProps = {
      * @deprecated
      */
     addNotification?: (notification: OldAlertDto) => void;
+    /**
+     * @deprecated use `riseNotification` instead
+     */
+    serviceBusNotification?: (message: AlertServiceBusMessage, //currently only used for alerts
+    apiKey: string, queue: string, topic: string) => Promise<unknown>;
     /**
      * @deprecated Use `showMessage` instead
      */
@@ -31,7 +37,7 @@ export type DeprecatedBaseProps = {
     addTranslation?: (translation: {
         key: string;
         value: string;
-    }) => void;
+    }, hide?: boolean) => void;
     /**
      * @deprecated Use `navigateInHortiview` instead
      */

package/dist/lib/types/Entities.d.ts

@@ -0,0 +1,22 @@
+import { Block, BlockPlantLayout, Farm, FarmAlertRule, FarmOrganization, Field, IrrigationStation, Season } from '../types/ModuleApi';
+export type HortiviewDataAreaGroup = 'FarmOrganization' | 'FarmMember';
+export type ModuleDataAreaGroup = 'ModuleDepended';
+export type FarmOrganizationEntities = 'farms' | 'fields' | 'zones' | 'irrigation_stations' | 'farm_organizations' | 'alert_rules';
+export type FarmMemberEntities = 'farm_members';
+export type ModuleDependendEntities = 'Season' | 'BlockPlantLayout' | (string & {});
+export type HortiviewDataAreaEntity<T extends HortiviewDataAreaGroup | ModuleDataAreaGroup> = T extends 'FarmOrganization' ? FarmOrganizationEntities : T extends 'FarmMember' ? FarmMemberEntities : T extends 'ModuleDepended' ? ModuleDependendEntities : never;
+export type ResultMap<T extends FarmMemberEntities | FarmOrganizationEntities | ModuleDependendEntities> = T extends 'zones' ? Block : T extends 'fields' ? Field : T extends 'farms' ? Farm : T extends 'irrigation_stations' ? IrrigationStation : T extends 'farm_organizations' ? FarmOrganization : T extends 'alert_rules' ? FarmAlertRule : T extends 'Season' ? Season : T extends 'BlockPlantLayout' ? BlockPlantLayout : unknown;
+export declare const FarmOrgEntitiesTypeResultMap: Record<FarmOrganizationEntities, string>;
+export declare const FarmMemberEntitiesTypeResultMap: Record<FarmMemberEntities, string>;
+export declare const ModuleDependedEntityTypeResultMap: Record<ModuleDependendEntities, string>;
+export declare const AllEntitiesTypeResultMap: {
+    Season: string;
+    BlockPlantLayout: string;
+    farm_members: string;
+    farms: string;
+    fields: string;
+    zones: string;
+    irrigation_stations: string;
+    farm_organizations: string;
+    alert_rules: string;
+};