@hortiview/modulebase 0.0.1 → 0.0.17-beta

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

@@ -3,14 +3,15 @@ export interface HortiViewEnvironments {
     MODULE_AUTH_API: string;
     API_PREFIX: string;
     ENVIRONMENT: string;
+    REQ_VERSION: string;
     [customkey: string]: string;
 }
 export interface CustomWindow extends Window {
     __env__?: HortiViewEnvironments;
 }
-export type Environments = 'DEVELOPMENT' | 'TEST' | 'BAYER-TEST' | 'BAYER-DEMO' | 'BAYER-PROD';
+export type Environments = 'SDC-DEV' | 'SDC-TEST' | 'SDC-DEMO' | 'BAYER-TES' | 'BAYER-DEM' | 'BAYER-STAG' | 'BAYER-PROD';
 export type EnvConfig = {
-    [key in Environments]: CustomEnv;
+    [key in Environments]?: CustomEnv;
 };
 export type CustomEnv = {
     [key: string]: string;

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

@@ -0,0 +1,6 @@
+export type EnvironmentVariable = {
+    id?: string;
+    key: string;
+    value: string;
+    appEnvironmentId: string | null;
+};

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

@@ -0,0 +1,163 @@
+export type RegisterOption = {
+    moduleId: string;
+    registeredEntityName: string;
+    id: string;
+};
+export interface ModuleEntity {
+    season: Season | undefined;
+    blockPlantLayout: BlockPlantLayout | undefined;
+}
+/**
+ * the basic interface for the module apis farm organization entities
+ */
+export interface FarmOrgEntity {
+    block: Block | undefined;
+    farm: Farm | undefined;
+    field: Field | undefined;
+    farmOrg: {
+        id: string;
+    } | undefined;
+    irrigationStation: {
+        id: string;
+    } | undefined;
+    farmAlertRule: {
+        id: string;
+    } | 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;
+    blockName?: string;
+    shortName?: string;
+    area?: number;
+    fieldPercentage?: number;
+    description?: string;
+    length?: number;
+    width?: number;
+    rows?: number;
+    /** Stringyfied Position, only used in BE */
+    location?: string;
+    /**Position will be transformed from the Location string, only internally used*/
+    position?: {
+        row: number;
+        column: number;
+    };
+};
+/**
+ * farm dto (only necessary fields - for now)
+ */
+export interface Farm {
+    id: string;
+    farmName: string;
+    description: string;
+    fields: Field[];
+    longitude: number;
+    latitude: number;
+    organizationId: string;
+    location: string;
+    primaryContactId: string;
+    secondaryContactId: string;
+    address: Address;
+}
+export interface Field {
+    farmId: string;
+    name: string;
+    description: string;
+    fieldTechnologyTypeId: string;
+    fieldCoverageTypeId: string;
+    fieldShadingTypeId: string;
+    fieldSowingTypeId: string;
+    fieldSubstrateTypeId: 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;
+    cropSeasonName: string;
+    startDate: Date;
+    plantingDate: Date | null;
+    cropId: string;
+    cropTypeId: string;
+    cropVarietyId: string;
+    rootstockId: string;
+    farmId: string;
+    fieldId: string;
+    seasonStateId?: string;
+}
+export interface BlockPlantLayout {
+    id: string;
+    blockId: string;
+    arrangementType: string | null;
+    offsetPlants: number;
+    offsetPlantsUnit: string;
+    rowLength: number;
+    rowLengthUnit: string;
+    offsetRows: number;
+    offsetRowsUnit: string;
+    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 → lib/types}/Requests.d.ts

@@ -1,17 +1,17 @@
 import { Expand, Filter, Select } from 'odata-query';
 export type RequestConfig = {
-    redirect: "follow";
-    credentials: "omit";
+    redirect: 'follow';
+    credentials: 'omit';
     headers: RequestHeader;
-    method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT";
+    method: httpMethod;
     body?: string | FormData;
 };
 export type RequestHeader = Headers & {
-    "Content-Type"?: "application/json";
+    'Content-Type'?: 'application/json';
     orgId?: string;
     Authorization?: string;
     Permission?: string;
-    "Api-Version"?: "1.0" | "2.0";
+    'Api-Version'?: '1.0' | '2.0';
     languageId?: string;
 };
 export type InternalError = {
@@ -41,9 +41,4 @@ export type BaseResponse<T> = T | T[] | {
 } | {
     items: T | T[];
 };
-/**
- * a universal selector that can be used for all fetches
- * @param data - the data to select from
- * @returns
- */
-export declare const universalSelector: <T>(data: BaseResponse<T>) => T | T[];
+export type httpMethod = 'POST' | 'PATCH' | 'DELETE' | 'PUT' | 'GET';

package/dist/lib/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/{utils/fetches.d.ts → lib/utils/api.d.ts}

@@ -1,11 +1,5 @@
-import { BaseResponse, Query, RequestConfig } from '../types/Requests';
-export declare const getFarmOrgEntities: <T>(moduleId: string, entityId: string) => Promise<BaseResponse<T>>;
-export declare const getModuleDependedEntities: <T>(moduleId: string, entityId: string) => Promise<BaseResponse<T>>;
-export declare const fetchFromCustomApi: <T>(endpoint: string, token?: string) => Promise<BaseResponse<T>>;
-export declare const fetchFromModuleApi: <T>(endpoint: string) => Promise<BaseResponse<T>>;
-export declare const fetchFromCommonApi: <T>(endpoint: string) => Promise<BaseResponse<T>>;
-export declare const baseFetch: <T>(url: string, query: Query, customToken?: string) => Promise<BaseResponse<T>>;
-export declare const getConfig: (token: string, organizationId?: string, languageId?: string, method?: "GET" | "POST" | "PATCH" | "DELETE" | "PUT") => RequestConfig;
+import { BaseResponse, httpMethod, Query, RequestConfig } from '../types/Requests';
+export declare const getConfig: (token?: string, organizationId?: string, languageId?: string, method?: httpMethod, customHeaders?: Headers) => RequestConfig;
 /**
  * a fetch function to handle requests and returns the response. if the response is unauthorized, it tries to refresh the token and retries the request
  * @param url - the complete url build by {@link prependBaseUrl}

package/dist/lib/utils/baseFetches.d.ts

@@ -0,0 +1,19 @@
+import { BaseResponse, httpMethod, Query } from '../types/Requests';
+/**
+ * a fetch function to handle CUD requests and returns the response.
+ * @param url endpoint to fetch (CUD) data from
+ * @param data data to send
+ * @param method method to use (POST, PUT, DELETE, PATCH)
+ * @param customToken token to use (default is the modulePermissionToken)
+ * @param headers (optional) custom headers to use
+ * @returns Promise<BaseResponse<R>> response from the fetch
+ */
+export declare const baseMutation: <T, R>(url: string, data: T, method: Omit<httpMethod, "GET">, customToken?: string, headers?: Headers, noAuth?: boolean) => Promise<BaseResponse<R>>;
+/**
+ * a fetch function to handle GET requests and returns the response.
+ * @param url url to GET data from
+ * @param query query to use for the GET request
+ * @param customToken token to use (default is the modulePermissionToken)
+ * @returns Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const baseFetch: <T>(url: string, query: Query, customToken?: string, noAuth?: boolean) => Promise<BaseResponse<T>>;

package/dist/lib/utils/fetches.d.ts

@@ -0,0 +1,43 @@
+import { httpMethod } from '../types/Requests';
+export declare const mutateOnCustomApi: <T, R>(endpoint: string, data: T, method?: Omit<httpMethod, "GET">, token?: string, headers?: Headers, noAuth?: boolean) => Promise<import('../main').BaseResponse<R>>;
+/**
+ * a fetch function to get a certain farmorganization entity from the moduleApi (will be used in useEntity)
+ * @param moduleId moduleID to get the entity from
+ * @param entityId entityID of the entity to get
+ * @returns entity to get
+ */
+export declare const getFarmOrgEntities: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ * a fetch function to get a certain MODULEDEPENDED entity from the moduleApi (will be used in useEntity)
+ * @param moduleId moduleID to get the entity from
+ * @param entityId entityID of the entity to get
+ * @returns entity to get
+ */
+export declare const getModuleDependedEntities: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ * a fetch function to get a certain MODULEDEPENDED entity from the moduleApi (will be used in useEntity)
+ * the data will be returned in a raw format
+ * @param moduleId
+ * @param entityId
+ * @returns
+ */
+export declare const getModuleDependedEntitiesRaw: <T>(moduleId: string, entityId: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint custom endpoint to GET data from
+ * @param token token to use (default is the modulePermissionToken)
+ * @returns Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromCustomApi: <T>(endpoint: string, token?: string, noAuth?: boolean) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint endpoint of moduleApi to fetch data from
+ * @returns  Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromModuleApi: <T>(endpoint: string) => Promise<import('../main').BaseResponse<T>>;
+/**
+ *  a fetch function to handle GET requests and returns the response.
+ * @param endpoint endpoint of commonApi to fetch data from
+ * @returns  Promise<BaseResponse<T>> response from the fetch
+ */
+export declare const fetchFromCommonApi: <T>(endpoint: string) => Promise<import('../main').BaseResponse<T>>;

package/dist/lib/utils/helper.d.ts

@@ -0,0 +1,29 @@
+import { BaseProps } from '../main';
+import { EnvConfig, Environments, HortiViewEnvironments } from '../types/Environment';
+import { BaseResponse } from '../types/Requests';
+/**
+ * Validates the props and checks if the required props are set
+ * @param props props to be validated
+ * @param requiredProps props that will be validated/checked if they exist
+ */
+export declare const arePropsValid: (props: BaseProps) => boolean;
+/**
+ * Checks if a prop exists and throws an error if it does not
+ * @param prop prop to be checked
+ * @param props props to be checked against
+ */
+export declare const checkIfPropExists: (prop: keyof BaseProps, props: BaseProps) => boolean;
+/**
+ * check if hortiview return the __env__ object correctly
+ * @returns the environment variables from the window object
+ */
+export declare const getEnvironmentVariables: () => HortiViewEnvironments | undefined;
+export declare const checkVersion: (environmentVariables?: HortiViewEnvironments) => string | null;
+/**
+ * a universal selector that can be used for all fetches
+ * @param data - the data to select from
+ * @returns
+ */
+export declare const universalSelector: <T>(data: BaseResponse<T>) => T | T[];
+export declare const checkConfig: <T extends EnvConfig>(config: T & Record<Exclude<keyof T, Environments>, never>) => T;
+export declare const getModuleQueryKey: (queryKey: (string | undefined)[]) => (string | undefined)[];

package/dist/main.js

@@ -1,19 +1,226 @@
-import { ModuleBase as r } from "./components/ModuleBase.js";
-import { useBreadcrumbTranslation as t } from "./hooks/useBreadcrumbTranslation.js";
-import { useNavigate as m } from "./hooks/useNavigate.js";
-import { useSignalRMessages as a } from "./hooks/useSignalRMessages.js";
-import { useBaseProps as x, useConfig as i } from "./hooks/useStores.js";
-import { useCustom as g } from "./hooks/useCustom.js";
-import { useEntity as B } from "./hooks/useEntity.js";
-import { useOption as C } from "./hooks/useOption.js";
+import { ModuleBase as A } from "./components/ModuleBase.js";
+import { i as S, h as l, b as m } from "./ModuleCore-YCIFN_02.js";
+import { M as U, Q as C } from "./ModuleCore-YCIFN_02.js";
+import { useBreadcrumbTranslation as b } from "./hooks/useBreadcrumbTranslation.js";
+import { useOffline as k } from "./hooks/useOffline.js";
+import { useSignalRMessages as w } from "./hooks/useSignalRMessages.js";
+import { useNavigate as D } from "./module-router.js";
+import { useBaseProps as L, useConfig as Q } from "./hooks/useStores.js";
+import { useCustom as T } from "./hooks/useCustom.js";
+import { useCustomMutation as K } from "./hooks/useCustomMutation.js";
+import { useEntity as z } from "./hooks/useEntity.js";
+import { useOption as j } from "./hooks/useOption.js";
+import { useNotification as J, useServiceBus as X } from "./hooks/useServiceBus.js";
+import { mutateOnCustomApi as Z } from "./utils/fetches.js";
+import { arePropsValid as ee, checkConfig as ae, checkIfPropExists as se, checkVersion as te, getEnvironmentVariables as re, getModuleQueryKey as oe, universalSelector as ie } from "./utils/helper.js";
+import { Q as d, a as E } from "./useQuery-Bj9k9zik.js";
+import { u as ne } from "./useQuery-Bj9k9zik.js";
+import { u as he } from "./useMutation-zu8uxBak.js";
+import { u as fe } from "./QueryClientProvider-Beog9TR7.js";
+import { A as le, B as me, F as de, H as Ee, I as Pe, a as ge, b as pe, L as Fe, c as Ne, M as xe, d as ve, N as Ae, e as _e, f as Ue, O as Ce, P as ye, R as be, g as Me, h as ke, i as Oe, S as we, j as Be, k as De, l as He, m as Le, D as Qe, n as Ie, E as Te, o as Ve, p as Ke, q as We, r as ze, s as Ge, t as je, u as qe, v as Je, V as Xe, w as Ye, x as Ze, y as $e, z as ea, C as aa, G as sa, J as ta, K as ra, Q as oa, T as ia, U as ua, W as na, X as ca, Y as ha, Z as Sa, _ as fa, $ as Ra, a0 as la, a1 as ma, a2 as da, a3 as Ea, a4 as Pa, a5 as ga, a6 as pa, a7 as Fa, a8 as Na, a9 as xa, aa as va, ab as Aa, ac as _a, ad as Ua, ae as Ca, af as ya, ag as ba, ah as Ma, ai as ka, aj as Oa, ak as wa, al as Ba, am as Da, an as Ha, ao as La, ap as Qa, aq as Ia, ar as Ta, as as Va, at as Ka, au as Wa, av as za, aw as Ga, ax as ja, ay as qa, az as Ja, aA as Xa, aB as Ya, aC as Za, aD as $a, aE as es, aF as as, aG as ss, aH as ts, aI as rs, aJ as os, aK as is, aL as us, aM as ns, aN as cs, aO as hs, aP as Ss, aQ as fs, aR as Rs, aS as ls, aT as ms, aU as ds, aV as Es, aW as Ps, aX as gs, aY as ps, aZ as Fs, a_ as Ns, a$ as xs } from "./chunk-QMGIS6GS-C4bgXQXY.js";
+var P = class extends d {
+  constructor(e, a) {
+    super(e, a);
+  }
+  bindMethods() {
+    super.bindMethods(), this.fetchNextPage = this.fetchNextPage.bind(this), this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+  }
+  setOptions(e, a) {
+    super.setOptions(
+      {
+        ...e,
+        behavior: S()
+      },
+      a
+    );
+  }
+  getOptimisticResult(e) {
+    return e.behavior = S(), super.getOptimisticResult(e);
+  }
+  fetchNextPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "forward" }
+      }
+    });
+  }
+  fetchPreviousPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "backward" }
+      }
+    });
+  }
+  createResult(e, a) {
+    const { state: t } = e, r = super.createResult(e, a), { isFetching: o, isRefetching: f, isError: i, isRefetchError: R } = r, s = t.fetchMeta?.fetchMore?.direction, u = i && s === "forward", n = o && s === "forward", c = i && s === "backward", h = o && s === "backward";
+    return {
+      ...r,
+      fetchNextPage: this.fetchNextPage,
+      fetchPreviousPage: this.fetchPreviousPage,
+      hasNextPage: l(a, t.data),
+      hasPreviousPage: m(a, t.data),
+      isFetchNextPageError: u,
+      isFetchingNextPage: n,
+      isFetchPreviousPageError: c,
+      isFetchingPreviousPage: h,
+      isRefetchError: R && !u && !c,
+      isRefetching: f && !n && !h
+    };
+  }
+};
+function N(e, a) {
+  return E(
+    e,
+    P,
+    a
+  );
+}
 export {
-  r as ModuleBase,
-  x as useBaseProps,
-  t as useBreadcrumbTranslation,
-  i as useConfig,
-  g as useCustom,
-  B as useEntity,
-  m as useNavigate,
-  C as useOption,
-  a as useSignalRMessages
+  le as Await,
+  me as BrowserRouter,
+  de as Form,
+  Ee as HashRouter,
+  Pe as IDLE_BLOCKER,
+  ge as IDLE_FETCHER,
+  pe as IDLE_NAVIGATION,
+  Fe as Link,
+  Ne as Links,
+  xe as MemoryRouter,
+  ve as Meta,
+  A as ModuleBase,
+  U as ModuleCore,
+  Ae as NavLink,
+  _e as Navigate,
+  Ue as NavigationType,
+  Ce as Outlet,
+  ye as PrefetchPageLinks,
+  C as QueryClient,
+  be as Route,
+  Me as Router,
+  ke as RouterProvider,
+  Oe as Routes,
+  we as Scripts,
+  Be as ScrollRestoration,
+  De as ServerRouter,
+  He as StaticRouter,
+  Le as StaticRouterProvider,
+  Qe as UNSAFE_DataRouterContext,
+  Ie as UNSAFE_DataRouterStateContext,
+  Te as UNSAFE_ErrorResponseImpl,
+  Ve as UNSAFE_FetchersContext,
+  Ke as UNSAFE_FrameworkContext,
+  We as UNSAFE_LocationContext,
+  ze as UNSAFE_NavigationContext,
+  Ge as UNSAFE_RemixErrorBoundary,
+  je as UNSAFE_RouteContext,
+  qe as UNSAFE_ServerMode,
+  Je as UNSAFE_SingleFetchRedirectSymbol,
+  Xe as UNSAFE_ViewTransitionContext,
+  Ye as UNSAFE_createBrowserHistory,
+  Ze as UNSAFE_createClientRoutes,
+  $e as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
+  ea as UNSAFE_createRouter,
+  aa as UNSAFE_decodeViaTurboStream,
+  sa as UNSAFE_deserializeErrors,
+  ta as UNSAFE_getHydrationData,
+  ra as UNSAFE_getPatchRoutesOnNavigationFunction,
+  oa as UNSAFE_getTurboStreamSingleFetchDataStrategy,
+  ia as UNSAFE_hydrationRouteProperties,
+  ua as UNSAFE_invariant,
+  na as UNSAFE_mapRouteProperties,
+  ca as UNSAFE_shouldHydrateRouteLoader,
+  ha as UNSAFE_useFogOFWarDiscovery,
+  Sa as UNSAFE_useScrollRestoration,
+  fa as UNSAFE_withComponentProps,
+  Ra as UNSAFE_withErrorBoundaryProps,
+  la as UNSAFE_withHydrateFallbackProps,
+  ee as arePropsValid,
+  ae as checkConfig,
+  se as checkIfPropExists,
+  te as checkVersion,
+  ma as createBrowserRouter,
+  da as createCookie,
+  Ea as createCookieSessionStorage,
+  Pa as createHashRouter,
+  ga as createMemoryRouter,
+  pa as createMemorySessionStorage,
+  Fa as createPath,
+  Na as createRequestHandler,
+  xa as createRoutesFromChildren,
+  va as createRoutesFromElements,
+  Aa as createRoutesStub,
+  _a as createSearchParams,
+  Ua as createSession,
+  Ca as createSessionStorage,
+  ya as createStaticHandler,
+  ba as createStaticRouter,
+  Ma as data,
+  ka as generatePath,
+  re as getEnvironmentVariables,
+  oe as getModuleQueryKey,
+  Oa as href,
+  wa as isCookie,
+  Ba as isRouteErrorResponse,
+  Da as isSession,
+  Ha as matchPath,
+  La as matchRoutes,
+  Z as mutateOnCustomApi,
+  Qa as parsePath,
+  Ia as redirect,
+  Ta as redirectDocument,
+  Va as renderMatches,
+  Ka as replace,
+  Wa as resolvePath,
+  ie as universalSelector,
+  za as unstable_HistoryRouter,
+  Ga as unstable_RouterContextProvider,
+  ja as unstable_createContext,
+  qa as unstable_setDevServerHooks,
+  Ja as unstable_usePrompt,
+  Xa as useActionData,
+  Ya as useAsyncError,
+  Za as useAsyncValue,
+  L as useBaseProps,
+  $a as useBeforeUnload,
+  es as useBlocker,
+  b as useBreadcrumbTranslation,
+  Q as useConfig,
+  T as useCustom,
+  K as useCustomMutation,
+  z as useEntity,
+  as as useFetcher,
+  ss as useFetchers,
+  ts as useFormAction,
+  rs as useHref,
+  os as useInRouterContext,
+  N as useInfiniteQuery,
+  is as useLinkClickHandler,
+  us as useLoaderData,
+  ns as useLocation,
+  cs as useMatch,
+  hs as useMatches,
+  he as useMutation,
+  D as useNavigate,
+  Ss as useNavigation,
+  fs as useNavigationType,
+  J as useNotification,
+  k as useOffline,
+  j as useOption,
+  Rs as useOutlet,
+  ls as useOutletContext,
+  ms as useParams,
+  ne as useQuery,
+  fe as useQueryClient,
+  ds as useResolvedPath,
+  Es as useRevalidator,
+  Ps as useRouteError,
+  gs as useRouteLoaderData,
+  ps as useRoutes,
+  Fs as useSearchParams,
+  X as useServiceBus,
+  w as useSignalRMessages,
+  Ns as useSubmit,
+  xs as useViewTransitionState
 };