@hortiview/modulebase 0.0.12333 → 0.0.12550

package/dist/query-CRIVoEP7.js

@@ -0,0 +1,277 @@
+import { R as d, r as l, a as u, b as f, s as p, t as y, c as v, n as b, e as m, i as h, d as S } from "./QueryClientProvider-Q_mWQTzQ.js";
+var q = class extends d {
+  #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 = F(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 = l(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) => f(t.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === p || 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 || !y(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)
+      });
+    }, c = () => {
+      const i = m(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: c
+    };
+    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 = v({
+      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,
+            ...C(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), b.batch(() => {
+      this.observers.forEach((s) => {
+        s.onQueryUpdate();
+      }), this.#e.notify({ query: this, type: "updated", action: t });
+    });
+  }
+};
+function C(t, e) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: S(e.networkMode) ? "fetching" : "paused",
+    ...t === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function F(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"
+  };
+}
+export {
+  q as Q,
+  C as f
+};

package/dist/types/BaseProps.d.ts

@@ -1,6 +1,7 @@
 import { AppInsightsEvent, AppInsightsException, AppInsightsProperties } from './AppInsights';
 import { AllDropdownsData, CommonOption } from './CommonOptions';
 import { DeprecatedBaseProps } from './Deprecated';
+import { AlertServiceBusMessage } from './ServiceBus';
 import { SystemMessage } from './SystemMessage';
 /**
  * Properties that are passed to the Base component by the host application
@@ -25,6 +26,8 @@ export type BaseProps = DeprecatedBaseProps & {
     currentLanguageId?: string;
     alertRules?: string;
     commonOptions?: AllDropdownsData<CommonOption>['items'];
+    serviceBusNotification?: (message: AlertServiceBusMessage, //currently only used for alerts
+    apiKey: string, queue: string, topic: string) => Promise<unknown>;
     navigateInHortiview?: (path: string) => void;
     addBreadcrumbTranslation?: (translation: {
         key: string;

package/dist/types/ModuleApi.d.ts

@@ -25,6 +25,19 @@ export interface FarmOrgEntity {
     } | undefined;
     id: string;
 }
+export interface FarmOrganization {
+    parentOrganizationId: string | null;
+    organizationName: string;
+    legalForm: string | null;
+    primaryContactId: string;
+    secondaryContactId: string | null;
+    creatorId: string;
+    addressId: string;
+    ownerId: string;
+    description: string | null;
+    address: Address;
+    id: string;
+}
 export type Block = {
     id: string;
     fieldId: string;
@@ -32,7 +45,6 @@ export type Block = {
     shortName?: string;
     area?: number;
     fieldPercentage?: number;
-    tagID?: string;
     description?: string;
     length?: number;
     width?: number;
@@ -55,14 +67,29 @@ export interface Farm {
     fields: Field[];
     longitude: number;
     latitude: number;
+    organizationId: string;
+    location: string;
+    primaryContactId: string;
+    secondaryContactId: string;
+    address: Address;
 }
 export interface Field {
-    id: string;
+    farmId: string;
     name: string;
     description: string;
-    farmId: string;
+    fieldTechnologyId: string;
     fieldCoverageId: string;
-    blocks: Block[];
+    fieldShadingId: string;
+    fieldSowingId: string;
+    fieldSubstrateId: string;
+    length: number | null;
+    width: number | null;
+    rows: number | null;
+    location: string;
+    area: number;
+    tag: string | null;
+    fieldTypeId: string;
+    id: string;
 }
 export interface Season {
     id: string;
@@ -90,3 +117,47 @@ export interface BlockPlantLayout {
     numberOfRows: number;
     numberOfPlants: number;
 }
+export interface IrrigationStation {
+    irrigationStationName: string;
+    farmId: string;
+    totalArea: number;
+    totalAreaUnit: string;
+    flow: number;
+    flowUnit: string;
+    irrigationZoneFields: IrrigationZoneField[];
+    id: string;
+}
+export interface FarmAlertRule {
+    farmOrganizationId: string;
+    moduleId: string;
+    farmId: string;
+    description: string;
+    descriptionTranslationsAsJson: string;
+    raisesNotification: boolean;
+    ruleAsJson: string;
+    recipients: string[];
+    id: string;
+}
+interface IrrigationZoneField {
+    fieldId: string;
+    irrigationZoneFieldBlocks: IrrigationZoneFieldBlock[];
+    id: string;
+}
+interface IrrigationZoneFieldBlock {
+    blockId: string;
+    id: string;
+}
+interface Address {
+    addressLine1: string;
+    addressLine2: string | null;
+    addressLine3: string | null;
+    directions: string | null;
+    city: string;
+    postalCode: string;
+    state: string;
+    countryId: string;
+    longitude: number;
+    latitude: number;
+    id: string;
+}
+export {};

package/dist/types/ServiceBus.d.ts

@@ -0,0 +1,17 @@
+export type AlertServiceBusMessage = {
+    farmOrganizationId: string;
+    alertRulesDefinitionId: string;
+    farmId: string;
+    fieldId: string;
+    blockId: string;
+    /**
+     * needs to be an ID that can be received from the common data/api
+     */
+    criteriaId: string;
+    moduleId: string;
+    description: string;
+};
+export type ServiceBusMessage = AlertServiceBusMessage & {
+    deviceId: '62ac8dbc-45bc-407d-9fb4-8efe9747abe0';
+    scope: 'FarmOrgMembers';
+};

package/dist/types/ServiceBus.js

@@ -0,0 +1 @@
+

package/dist/useMutation-3rykrmeD.js

@@ -0,0 +1,97 @@
+import * as n from "react";
+import { g as l } from "./mutation-X73nm7Df.js";
+import { S as d, f as p, h, n as a, u as b } from "./QueryClientProvider-Q_mWQTzQ.js";
+import { n as m, s as f } from "./utils-DxRR_XLb.js";
+var v = class extends d {
+  #e;
+  #i = void 0;
+  #t;
+  #s;
+  constructor(t, s) {
+    super(), this.#e = t, this.setOptions(s), this.bindMethods(), this.#r();
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(t) {
+    const s = this.options;
+    this.options = this.#e.defaultMutationOptions(t), p(this.options, s) || this.#e.getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: this.#t,
+      observer: this
+    }), s?.mutationKey && this.options.mutationKey && h(s.mutationKey) !== h(this.options.mutationKey) ? this.reset() : this.#t?.state.status === "pending" && this.#t.setOptions(this.options);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.#t?.removeObserver(this);
+  }
+  onMutationUpdate(t) {
+    this.#r(), this.#n(t);
+  }
+  getCurrentResult() {
+    return this.#i;
+  }
+  reset() {
+    this.#t?.removeObserver(this), this.#t = void 0, this.#r(), this.#n();
+  }
+  mutate(t, s) {
+    return this.#s = s, this.#t?.removeObserver(this), this.#t = this.#e.getMutationCache().build(this.#e, this.options), this.#t.addObserver(this), this.#t.execute(t);
+  }
+  #r() {
+    const t = this.#t?.state ?? l();
+    this.#i = {
+      ...t,
+      isPending: t.status === "pending",
+      isSuccess: t.status === "success",
+      isError: t.status === "error",
+      isIdle: t.status === "idle",
+      mutate: this.mutate,
+      reset: this.reset
+    };
+  }
+  #n(t) {
+    a.batch(() => {
+      if (this.#s && this.hasListeners()) {
+        const s = this.#i.variables, i = this.#i.context;
+        t?.type === "success" ? (this.#s.onSuccess?.(t.data, s, i), this.#s.onSettled?.(t.data, null, s, i)) : t?.type === "error" && (this.#s.onError?.(t.error, s, i), this.#s.onSettled?.(
+          void 0,
+          t.error,
+          s,
+          i
+        ));
+      }
+      this.listeners.forEach((s) => {
+        s(this.#i);
+      });
+    });
+  }
+};
+function C(t, s) {
+  const i = b(), [e] = n.useState(
+    () => new v(
+      i,
+      t
+    )
+  );
+  n.useEffect(() => {
+    e.setOptions(t);
+  }, [e, t]);
+  const r = n.useSyncExternalStore(
+    n.useCallback(
+      (o) => e.subscribe(a.batchCalls(o)),
+      [e]
+    ),
+    () => e.getCurrentResult(),
+    () => e.getCurrentResult()
+  ), u = n.useCallback(
+    (o, c) => {
+      e.mutate(o, c).catch(m);
+    },
+    [e]
+  );
+  if (r.error && f(e.options.throwOnError, [r.error]))
+    throw r.error;
+  return { ...r, mutate: u, mutateAsync: r.mutate };
+}
+export {
+  C as u
+};