@geowiki/core 0.15.0-dev.1

package/dist/index.mjs

@@ -0,0 +1,3243 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Animation.ts
+var easing = [0.175, 0.85, 0.42, 0.96];
+var listVariants = {
+  initial: { scale: 0.96, y: 30, opacity: 0 },
+  enter: {
+    scale: 1,
+    y: 0,
+    opacity: 1,
+    transition: {
+      duration: 0.5,
+      ease: [0.48, 0.15, 0.25, 0.96],
+      staggerChildren: 0.1,
+      delayChildren: 0.2
+    }
+  },
+  exit: {
+    transition: { staggerChildren: 0.1, staggerDirection: -1 }
+  }
+};
+var itemVariants = {
+  initial: {
+    y: 50,
+    opacity: 0,
+    transition: {
+      y: { stiffness: 1e3 }
+    }
+  },
+  enter: {
+    y: 0,
+    opacity: 1,
+    transition: {
+      y: { stiffness: 1e3, velocity: -100 }
+    }
+  },
+  exit: {
+    y: 50,
+    opacity: 0,
+    transition: {
+      y: { stiffness: 1e3, velocity: -100 }
+    }
+  }
+};
+var slideInUp = {
+  exit: {
+    y: 100,
+    opacity: 0,
+    transition: { duration: 0.2, ease: easing }
+  },
+  enter: {
+    y: 0,
+    opacity: 1,
+    transition: { delay: 0.1, duration: 0.5, ease: easing }
+  }
+};
+var delayedSlideInUp = {
+  exit: {
+    y: 100,
+    opacity: 0,
+    transition: { duration: 0.2, ease: easing }
+  },
+  enter: {
+    y: 0,
+    opacity: 1,
+    transition: {
+      delay: 0.2,
+      duration: 0.5,
+      ease: easing
+    }
+  }
+};
+var slideInLeft = {
+  exit: {
+    x: -100,
+    opacity: 0,
+    transition: { duration: 0.4, ease: easing }
+  },
+  enter: {
+    x: 0,
+    opacity: 1,
+    transition: { delay: 0.1, duration: 0.5, ease: easing }
+  }
+};
+var slideInRight = {
+  exit: { x: 150, opacity: 0, transition: { duration: 0.4, ease: easing } },
+  enter: {
+    x: 0,
+    opacity: 1,
+    transition: {
+      duration: 0.5,
+      ease: easing
+    }
+  }
+};
+var spring = {
+  type: "spring",
+  stiffness: 500,
+  damping: 30
+};
+
+// src/hooks/QueryConstants.ts
+var QueryConstants = {
+  GetUsers: "GetUsers",
+  GetTenants: "GetTenants",
+  GetRoles: "GetRoles",
+  GetAppConfig: "GetAppConfig",
+  GetFeatures: "GetFeatures",
+  GetTranslations: "GetTranslations",
+  GetPermissions: "GetPermissions",
+  GetUserRoles: "GetUserRoles",
+  SetUserDetail: "SetUserDetail",
+  GetEmailing: "GetEmailing",
+  GetAssignableRoles: "GetAssignableRoles",
+  GetProfile: "GetProfile",
+  GetProjects: "GetProjects",
+  GetProjectDetails: "GetProjectDetails",
+  GetProjectResultSet: "GetProjectResultSet",
+  DownlaodProjectsPoints: "DownlaodProjectsPoints",
+  GetProjectStatisticsByUser: "GetProjectStatisticsByUser",
+  GetContractStatisticsByUser: "GetContractStatisticsByUser",
+  GetGroupsInProject: "GetGroupsInProject",
+  UpdateActiveGroupsInProject: "UpdateActiveGroupsInProject",
+  GetProjectUsers: "GetProjectUsers",
+  GetUserProject: "GetUserProject",
+  SetProjectUser: "SetProjectUser",
+  GetLocations: "GetLocations",
+  UploadLocations: "UploadLocations",
+  GetLatestTaskOnLocation: "GetLatestTaskOnLocation",
+  GetTasksPerLocation: "GetTasksPerLocation",
+  GetTaskComment: "GetTaskComment",
+  GetTaskStatusList: "GetTaskStatusList",
+  GetTaskAnnotation: "GetTaskAnnotation",
+  GetTaskMultipleAnnotations: "GetTaskMultipleAnnotations",
+  GetTaskSavedAnnotations: "GetTaskSavedAnnotations",
+  DeleteTask: "DeleteTask",
+  GetApiImage: "GetApiImage",
+  GetCmsImage: "GetCmsImage",
+  GetQuestionnaireForProject: "GetQuestionnaireForProject",
+  GetTaskAnswers: "GetTaskAnswers",
+  UploadTasks: "UploadTasks",
+  UploadReviewTasks: "UploadReviewTasks"
+};
+
+// src/hooks/useEvolandBands.ts
+import { useQuery } from "@tanstack/react-query";
+
+// src/Constants/QueryNames.ts
+var QueryNames = {
+  Users: "Users",
+  Tenants: "Tenants",
+  Roles: "Roles",
+  AppConfig: "AppConfig",
+  GetMapMenuItems: "GetMapMenuItems",
+  GetApps: "GetApps",
+  GetCountries: "GetCountries",
+  Clusters: "Clusters",
+  Cluster: "Cluster",
+  ClusterNewsWithId: "ClusterNewsWithId",
+  GetClusterOverview: "GetClusterOverview",
+  FilterClusters: "FilterClusters",
+  ClusterLookUp: "ClusterLookUp",
+  JoinRequests: "JoinRequests",
+  GetFarmerCluster: "GetFarmerCluster",
+  GetFarmerClusterNews: "GetFarmerClusterNews",
+  GetFarmerClusterMembers: "GetFarmerClusterMembers",
+  Menus: "Menus",
+  GetMenu: "GetMenu",
+  GetSettings: "GetSettings",
+  Layers: "Layers",
+  GetLayer: "GetLayer",
+  GetClusterForMap: "GetClusterForMap",
+  GetAppSettings: "GetAppSettings",
+  GetResource: "GetResource",
+  FileUpload: "FileUpload",
+  // PLOP_QUERY_NAMES
+  GetUserProfile: "GetUserProfile",
+  GetLookUp: "GetLookUp",
+  GetClusterFilterSettings: "GetClusterFilterSettings",
+  GetConfig: "GetConfig",
+  GetIntroTour: "GetIntroTour",
+  GetNews: "GetNews",
+  GetPublicationSettings: "GetPublicationSettings",
+  GetUseLayerInfo: "GetUseLayerInfo",
+  GetMapSettings: "GetMapSettings",
+  GetLanguages: "GetLanguages",
+  GetResourceFilter: "GetResourceFilter",
+  GetAudience: "GetAudience",
+  GetTopic: "GetTopic",
+  GetResourceType: "GetResourceType",
+  GetAvailableWmsLayers: "GetAvailableWmsLayers",
+  GetAvailableBands: "GetAvailableBands",
+  ClusterAllNews: "ClusterAllNews",
+  ClusterNews: "ClusterNews",
+  ClusterGetNews: "ClusterGetNews",
+  ClusterNewsNextPrevious: "ClusterNewsNextPrevious",
+  ClusterImages: "ClusterImages",
+  DefaultSettings: "DefaultSettings",
+  GetEvolandLabels: "GetEvolandLabels",
+  GetEvolandCombinationLabels: "GetEvolandCombinationLabels",
+  NewsFromAllClusters: "NewsFromAllClusters",
+  MapMenuItems: "MapMenuItems",
+  GetSocialLinks: "GetSocialLinks",
+  GetCmsContentWithType: "GetCmsContentWithType",
+  GetImagesAndVideos: "GetImagesAndVideos",
+  GetClusterDescription: "GetClusterDescription",
+  GetClusterDetails: "GetClusterDetails",
+  GetHost: "GetHost",
+  GetHosts: "GetHosts"
+};
+
+// src/hooks/useEvolandBands.ts
+var useEvolandBands = () => {
+  return useQuery({
+    queryKey: [QueryNames.GetAvailableBands],
+    queryFn: () => {
+    }
+  });
+};
+
+// src/hooks/useEvolandWmsLayers.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { ProjectService } from "@geowiki/evoland-api-proxy";
+var useEvolandWmsLayers = () => {
+  return useQuery2({
+    queryKey: [QueryNames.GetAvailableWmsLayers],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ProjectService.getAvailableLayersAvailablelayersGet();
+      return data;
+    })
+  });
+};
+
+// src/stores/config.ts
+import { createStore } from "zustand/vanilla";
+var configStore = createStore((set) => ({
+  apiUrl: "",
+  cmsUrl: "",
+  tenantId: "",
+  setApiUrl: (url) => set({ apiUrl: url }),
+  setCmsUrl: (url) => set({ cmsUrl: url }),
+  setTenant: (tenant) => set({ tenantId: tenant })
+}));
+var config_default = configStore;
+
+// src/hooks/useApiUrl.ts
+var useApiUrl = () => {
+  return config_default.getState().apiUrl;
+};
+
+// src/hooks/useAppConfig.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+import {
+  AbpApplicationConfigurationService
+} from "@geowiki/api-proxy";
+var useAppConfig = () => {
+  return useQuery3({
+    queryKey: [QueryConstants.GetAppConfig],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield AbpApplicationConfigurationService.abpApplicationConfigurationGet();
+      return data;
+    }),
+    staleTime: 60 * 60 * 1e3
+    // 1 hour
+  });
+};
+
+// src/hooks/useAudience.ts
+import { ResourceService } from "@geowiki/api-proxy";
+import { keepPreviousData, useQuery as useQuery4 } from "@tanstack/react-query";
+var useAudience = () => {
+  return useQuery4({
+    queryKey: [QueryNames.GetAudience],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ResourceService.resourceGetAvailableAudience();
+      return data;
+    }),
+    staleTime: 1e3 * 60 * 60 * 24,
+    gcTime: 1e3 * 60 * 60 * 24,
+    placeholderData: keepPreviousData
+  });
+};
+
+// src/hooks/useCluster.ts
+import { ClusterService } from "@geowiki/api-proxy";
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+var useCluster = (id) => {
+  return useQuery5({
+    queryKey: [QueryNames.Cluster, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService.clusterGet(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterFilterSettings.ts
+import {
+  SettingsService
+} from "@geowiki/cms-proxy";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
+var useClusterFilterSettings = () => {
+  return useQuery6({
+    queryKey: [QueryNames.GetClusterFilterSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield SettingsService.settingsGetSiteSettings("ClusterFilter");
+      return req;
+    })
+  });
+};
+var useConfigSettings = () => {
+  return useQuery6({
+    queryKey: [QueryNames.GetConfig],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield SettingsService.settingsGetSiteSettings("Config");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterMapInfo.ts
+import { ClusterService as ClusterService2 } from "@geowiki/api-proxy";
+import { useQuery as useQuery7 } from "@tanstack/react-query";
+var useClusterMapInfo = () => {
+  return useQuery7({
+    queryKey: [QueryNames.GetClusterForMap],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService2.clusterGetMapInfo();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusters.ts
+import { ClusterService as ClusterService3 } from "@geowiki/api-proxy";
+import { keepPreviousData as keepPreviousData2, useQuery as useQuery8 } from "@tanstack/react-query";
+var useClusters = (fetchAll = false, sort = "", skip = 0, take = 100) => {
+  return useQuery8({
+    queryKey: [QueryNames.Clusters, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetchAll) {
+        const data = yield ClusterService3.clusterGetAllClusters(
+          sort,
+          skip,
+          take
+        );
+        return data;
+      } else {
+        const data = yield ClusterService3.clusterGetList(sort, skip, take);
+        return data;
+      }
+    }),
+    placeholderData: keepPreviousData2
+  });
+};
+var useAllNewsFromAllClusters = (sort = "", skip = 0, take = 100) => {
+  return useQuery8({
+    queryKey: [QueryNames.GetFarmerClusterNews, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService3.clusterGetAllNewsFromAllClusters(
+        sort,
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useHosts.ts
+import { useQuery as useQuery9 } from "@tanstack/react-query";
+var getHosts = () => __async(void 0, null, function* () {
+  const response = yield fetch("/api/hosts");
+  if (!response.ok) {
+    throw new Error("Failed to fetch hosts");
+  }
+  return response.json();
+});
+function useHosts() {
+  return useQuery9({
+    queryKey: [QueryNames.GetHosts],
+    queryFn: getHosts,
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutes
+    // React Query v5 renamed cacheTime to gcTime
+    gcTime: 10 * 60 * 1e3
+    // 10 minutes
+  });
+}
+
+// src/hooks/useCmsUrl.ts
+var useCmsUrl = () => {
+  const { data: hosts, isLoading } = useHosts();
+  var cmsUrl = config_default.getState().cmsUrl;
+  if (!cmsUrl && !isLoading && hosts) {
+    console.error("CMS URL not found in the store");
+    var host = window.location.host;
+    var hostInfo = hosts.find((h) => h.host === host);
+    if (hostInfo) {
+      cmsUrl = hostInfo.cmsUrl;
+    }
+  }
+  return cmsUrl || "https://cms.geo-wiki.org";
+};
+
+// src/hooks/useCountries.ts
+import { useQuery as useQuery10 } from "@tanstack/react-query";
+import { ClusterService as ClusterService4 } from "@geowiki/api-proxy";
+var useCountries = (fetchAll = false) => {
+  return useQuery10({
+    queryKey: [QueryNames.GetCountries, fetchAll],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService4.clusterGetCountries(fetchAll);
+      data.sort((a, b) => {
+        if (!a.country || !b.country) {
+          return -1;
+        }
+        if (a.country < b.country) {
+          return -1;
+        }
+        if (a.country > b.country) {
+          return 1;
+        }
+        return 0;
+      });
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24
+    // 24 hours
+  });
+};
+
+// src/hooks/useDimensions.ts
+import { useEffect, useRef } from "react";
+var useDimensions = (ref) => {
+  const dimensions = useRef({ width: 0, height: 0 });
+  useEffect(() => {
+    var _a, _b;
+    dimensions.current.width = (_a = ref.current) == null ? void 0 : _a.offsetWidth;
+    dimensions.current.height = (_b = ref.current) == null ? void 0 : _b.offsetHeight;
+  }, []);
+  return dimensions.current;
+};
+
+// src/hooks/useFeature.ts
+var useFeature = (key) => {
+  var _a, _b, _c;
+  const { data } = useAppConfig();
+  return ((_c = (_b = (_a = data == null ? void 0 : data.features) == null ? void 0 : _a.values) == null ? void 0 : _b[key]) == null ? void 0 : _c.toLowerCase()) === "true";
+};
+
+// src/hooks/useFile.ts
+import { FileService } from "@geowiki/api-proxy";
+import { useQuery as useQuery11 } from "@tanstack/react-query";
+var useFileUrl = () => {
+  var tenant = config_default.getState().tenantId;
+  var url = `${process.env.NEXT_PUBLIC_API_URL}/api/app/file/view?__tenant=${tenant}&id=`;
+  return url;
+};
+var useFileUpload = (formData) => {
+  return useQuery11({
+    queryKey: [QueryNames.FileUpload, formData],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield FileService.fileUpload(formData);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useFilterClusters.ts
+import { ClusterService as ClusterService5 } from "@geowiki/api-proxy";
+import { useQuery as useQuery12 } from "@tanstack/react-query";
+var useFilterClusters = (filter) => {
+  return useQuery12({
+    queryKey: [
+      QueryNames.FilterClusters,
+      filter.skip,
+      filter.take,
+      filter.country,
+      filter.activityStatus,
+      filter.farmingSystem,
+      filter.mainCrop,
+      filter.mainAgriculturalAreas,
+      filter.sort
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService5.clusterFilter(filter);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useGeoWikiSettings.ts
+import { SettingsService as SettingsService2 } from "@geowiki/cms-proxy";
+import { useQuery as useQuery13 } from "@tanstack/react-query";
+var useGeoWikiSettings = () => {
+  return useQuery13({
+    queryKey: [QueryNames.GetAppSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield SettingsService2.settingsGetSiteSettings("GeoWiki");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useImageUrl.ts
+var useImageUrl = () => {
+  var cmsUrl = useCmsUrl();
+  return `${cmsUrl}/media/`;
+};
+
+// src/hooks/useIntroTourSettings.ts
+import { SettingsService as SettingsService3 } from "@geowiki/cms-proxy";
+import { useQuery as useQuery14 } from "@tanstack/react-query";
+var useIntroTourSettings = () => {
+  return useQuery14({
+    queryKey: [QueryNames.GetIntroTour],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield SettingsService3.settingsGetSiteSettings("IntroTour");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useIsAdmin.ts
+var useIsAdmin = () => {
+  var _a, _b;
+  const { data } = useAppConfig();
+  return (_b = (_a = data == null ? void 0 : data.currentUser) == null ? void 0 : _a.roles) == null ? void 0 : _b.includes("admin");
+};
+
+// src/hooks/useIsAuthenticated.ts
+var useIsAuthenticated = () => {
+  var _a;
+  var { data } = useAppConfig();
+  return (_a = data == null ? void 0 : data.currentUser) == null ? void 0 : _a.isAuthenticated;
+};
+
+// src/hooks/useIsInRole.ts
+var useIsInRole = (role) => {
+  var _a, _b;
+  const { data, isLoading } = useAppConfig();
+  return {
+    data: (_b = (_a = data == null ? void 0 : data.currentUser) == null ? void 0 : _a.roles) == null ? void 0 : _b.includes(role),
+    isLoading
+  };
+};
+
+// src/hooks/useLanguages.ts
+import { ResourceService as ResourceService2 } from "@geowiki/api-proxy";
+import { keepPreviousData as keepPreviousData3, useQuery as useQuery15 } from "@tanstack/react-query";
+var useLanguages = () => {
+  return useQuery15({
+    queryKey: [QueryNames.GetLanguages],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ResourceService2.resourceGetAvailableLanguages();
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: keepPreviousData3
+  });
+};
+
+// src/hooks/useLayerInfo.ts
+import { useQuery as useQuery16 } from "@tanstack/react-query";
+var useLayerInfo = (url, layerName) => {
+  return useQuery16({
+    queryKey: [QueryNames.GetUseLayerInfo, url, layerName],
+    queryFn: () => __async(void 0, null, function* () {
+      var legendUrl = url + "?service=WMS&version=1.1.0&request=GetLegendGraphic&layer=" + layerName + "&format=application/json";
+      var res = yield fetch(legendUrl);
+      var data = yield res.json();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useLocation.ts
+import { useEffect as useEffect2, useState } from "react";
+import { ProjectService as ProjectService2, LocationService } from "@geowiki/evoland-api-proxy";
+import { useQuery as useQuery17 } from "@tanstack/react-query";
+function useLocation() {
+  const [location, setLocation] = useState();
+  useEffect2(() => {
+    navigator.geolocation.getCurrentPosition(function(position) {
+      setLocation(position.coords);
+    });
+  }, []);
+  return location;
+}
+var useLocationsForProject = (locationreq) => {
+  return useQuery17({
+    queryKey: [QueryConstants.GetLocations, locationreq],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService2.searchLocationsLocationsPost(locationreq);
+    })
+  });
+};
+var useLocationBulkUpload = (uploadLocations, file, project_id, group_id) => {
+  return useQuery17({
+    queryKey: [QueryConstants.UploadLocations, uploadLocations, file, group_id],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        const res = yield LocationService.bulkUploadLocationsUploadlocationsPost({ file, project_id, group_id });
+        return res;
+      } catch (error) {
+        return { data: error.body, isLoading: false, error: true };
+      }
+    }),
+    enabled: !!uploadLocations && !!file && !!group_id
+  });
+};
+var useTaskBulkUpload = (uploadTasks, file, project_id) => {
+  return useQuery17({
+    queryKey: [QueryConstants.UploadTasks, uploadTasks, file],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        return LocationService.uploadLocationTaskUploadlocationtaskPost({ file, project_id });
+      } catch (error) {
+        return { data: error.body, isLoading: false, error: true };
+      }
+    }),
+    enabled: !!uploadTasks && !!file
+  });
+};
+var useReviewTaskBulkUpload = (uploadReviewTasks, file, project_id) => {
+  return useQuery17({
+    queryKey: [QueryConstants.UploadReviewTasks, uploadReviewTasks, file],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        return LocationService.bulkUploadReviewTasksUploadreviewtasksPost({ file, project_id });
+      } catch (error) {
+        return { data: error.body, isLoading: false, error: true };
+      }
+    }),
+    enabled: !!uploadReviewTasks && !!file
+  });
+};
+
+// src/hooks/useLockBodyScroll.ts
+import { useEffect as useEffect3 } from "react";
+function useLockBodyScroll() {
+  useEffect3(() => {
+    const originalStyle = window.getComputedStyle(document.body).overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = originalStyle;
+    };
+  }, []);
+}
+
+// src/hooks/useMapSettings.ts
+import { SettingsService as SettingsService4 } from "@geowiki/cms-proxy";
+import { useQuery as useQuery18 } from "@tanstack/react-query";
+
+// src/hooks/useNews.ts
+import { keepPreviousData as keepPreviousData4, useQuery as useQuery19 } from "@tanstack/react-query";
+import { NewsService } from "@geowiki/api-proxy";
+var useNews = (lang = "all", skip = 0, take = 100) => {
+  return useQuery19({
+    queryKey: [QueryNames.GetNews, lang, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (lang == "all") {
+        const res2 = yield NewsService.newsGetExternalNews("", skip, take);
+        return res2.items;
+      }
+      const res = yield NewsService.newsGetExternalNewsByLanguage(
+        "",
+        skip,
+        take,
+        lang
+      );
+      return res.items;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    placeholderData: keepPreviousData4,
+    staleTime: 1e3 * 60 * 60 * 24
+  });
+};
+
+// src/hooks/usePagination.ts
+import { useMemo } from "react";
+var range = (start, end) => {
+  let length = end - start + 1;
+  return Array.from({ length }, (_, idx) => idx + start);
+};
+var DOTS = "...";
+var usePagination = ({
+  totalCount,
+  pageSize,
+  siblingCount = 1,
+  currentPage
+}) => {
+  const paginationRange = useMemo(() => {
+    const totalPageCount = Math.ceil(totalCount / pageSize);
+    const totalPageNumbers = siblingCount + 5;
+    if (totalPageNumbers >= totalPageCount) {
+      return range(1, totalPageCount);
+    }
+    const leftSiblingIndex = Math.max(currentPage - siblingCount, 1);
+    const rightSiblingIndex = Math.min(
+      currentPage + siblingCount,
+      totalPageCount
+    );
+    const shouldShowLeftDots = leftSiblingIndex > 2;
+    const shouldShowRightDots = rightSiblingIndex < totalPageCount - 2;
+    const firstPageIndex = 1;
+    const lastPageIndex = totalPageCount;
+    if (!shouldShowLeftDots && shouldShowRightDots) {
+      let leftItemCount = 3 + 2 * siblingCount;
+      let leftRange = range(1, leftItemCount);
+      return [...leftRange, DOTS, totalPageCount];
+    }
+    if (shouldShowLeftDots && !shouldShowRightDots) {
+      let rightItemCount = 3 + 2 * siblingCount;
+      let rightRange = range(
+        totalPageCount - rightItemCount + 1,
+        totalPageCount
+      );
+      return [firstPageIndex, DOTS, ...rightRange];
+    }
+    if (shouldShowLeftDots && shouldShowRightDots) {
+      let middleRange = range(leftSiblingIndex, rightSiblingIndex);
+      return [firstPageIndex, DOTS, ...middleRange, DOTS, lastPageIndex];
+    }
+  }, [totalCount, pageSize, siblingCount, currentPage]);
+  return paginationRange;
+};
+
+// src/hooks/usePermission.ts
+var usePermission = (key) => {
+  var _a, _b;
+  var { data } = useAppConfig();
+  return ((_b = (_a = data == null ? void 0 : data.auth) == null ? void 0 : _a.grantedPolicies) == null ? void 0 : _b[key]) === true;
+};
+
+// src/hooks/usePublicationSettings.ts
+import {
+  SettingsService as SettingsService5
+} from "@geowiki/cms-proxy";
+import { useQuery as useQuery20 } from "@tanstack/react-query";
+var usePublicationSettings = () => {
+  return useQuery20({
+    queryKey: [QueryNames.GetPublicationSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield SettingsService5.settingsGetSiteSettings("Publication");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useResource.ts
+import { ResourceService as ResourceService3 } from "@geowiki/api-proxy";
+import { keepPreviousData as keepPreviousData5, useQuery as useQuery21 } from "@tanstack/react-query";
+var useResource = (search = "", sort = "", skip = 0, take = 100) => {
+  return useQuery21({
+    queryKey: [QueryNames.GetResource, search, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (search !== "") {
+        const data2 = yield ResourceService3.resourceSearch(search);
+        return data2;
+      }
+      const data = yield ResourceService3.resourceGetAll(sort, skip, take);
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: keepPreviousData5
+  });
+};
+
+// src/hooks/useResourceFilter.ts
+import { ResourceService as ResourceService4 } from "@geowiki/api-proxy";
+import { useQuery as useQuery22 } from "@tanstack/react-query";
+var useResourceFilter = (filter) => {
+  return useQuery22({
+    queryKey: [
+      QueryNames.GetResourceFilter,
+      filter.from,
+      filter.language,
+      filter.topic,
+      filter.resourceType,
+      filter.search,
+      filter.audience,
+      filter.currentPage,
+      filter.pageSize,
+      filter.sorting,
+      filter.isFramework
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ResourceService4.resourceFilter(filter);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useResourceType.ts
+import { ResourceService as ResourceService5 } from "@geowiki/api-proxy";
+import { useQuery as useQuery23 } from "@tanstack/react-query";
+var useResourceType = () => {
+  return useQuery23({
+    queryKey: [QueryNames.GetResourceType],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield ResourceService5.resourceGetAvailableResourceType();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useTopic.ts
+import { ResourceService as ResourceService6 } from "@geowiki/api-proxy";
+import { keepPreviousData as keepPreviousData6, useQuery as useQuery24 } from "@tanstack/react-query";
+var useTopic = () => {
+  return useQuery24({
+    queryKey: [QueryNames.GetTopic],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield ResourceService6.resourceGetAvailableTopic();
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: keepPreviousData6
+  });
+};
+
+// src/hooks/useUserProfile.ts
+import { useQuery as useQuery25 } from "@tanstack/react-query";
+import { ProfileService } from "@geowiki/api-proxy";
+var useUserProfileGet = () => {
+  return useQuery25({
+    queryKey: [QueryNames.GetUserProfile],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield ProfileService.profileGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useUsers.ts
+import { useQuery as useQuery26 } from "@tanstack/react-query";
+import { UserService } from "@geowiki/api-proxy";
+var useUsers = (pageIndex, pageSize, filter, sorting) => {
+  return useQuery26({
+    queryKey: [QueryConstants.GetUsers, pageIndex, pageSize, filter, sorting],
+    queryFn: () => __async(void 0, null, function* () {
+      let skip = 0;
+      if (pageIndex > 0) {
+        skip = pageIndex * pageSize;
+      }
+      const data = yield UserService.userGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useRenderInfo.ts
+import React from "react";
+function useRenderInfo(name = "Unknown") {
+  const count = React.useRef(0);
+  const lastRender = React.useRef();
+  const now = Date.now();
+  count.current++;
+  React.useEffect(() => {
+    lastRender.current = Date.now();
+  });
+  const sinceLastRender = lastRender.current ? now - lastRender.current : 0;
+  if (process.env.NODE_ENV !== "production") {
+    const info = {
+      name,
+      renders: count.current,
+      sinceLastRender,
+      timestamp: now
+    };
+    return info;
+  }
+}
+
+// src/hooks/useDefaultSettings.ts
+import { SettingsService as SettingsService6 } from "@geowiki/cms-proxy";
+import { useQuery as useQuery27 } from "@tanstack/react-query";
+var useDefaultSettings = () => {
+  return useQuery27({
+    queryKey: [QueryNames.DefaultSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield SettingsService6.settingsGetDefaultSiteSettings();
+      return req;
+    })
+  });
+};
+
+// src/hooks/useCurrentUser.ts
+var useCurrentUser = () => {
+  const { data } = useAppConfig();
+  return data == null ? void 0 : data.currentUser;
+};
+
+// src/hooks/useEmailing.ts
+import { EmailSettingsService } from "@geowiki/api-proxy";
+import { useQuery as useQuery28 } from "@tanstack/react-query";
+var useEmailing = () => {
+  return useQuery28({
+    queryKey: [QueryConstants.GetEmailing],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield EmailSettingsService.emailSettingsGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useGrantedPolicies.ts
+import { useCallback } from "react";
+var useGrantedPolicies = () => {
+  var _a;
+  const { data } = useAppConfig();
+  const can = useCallback(
+    (key) => {
+      var _a2;
+      if (((_a2 = data == null ? void 0 : data.auth) == null ? void 0 : _a2.grantedPolicies) && !!data.auth.grantedPolicies[key])
+        return true;
+      return false;
+    },
+    [(_a = data == null ? void 0 : data.auth) == null ? void 0 : _a.grantedPolicies]
+  );
+  return { can };
+};
+
+// src/hooks/useFeatures.ts
+import { FeaturesService } from "@geowiki/api-proxy";
+import { useQuery as useQuery29 } from "@tanstack/react-query";
+var useFeatures = (providerName, providerKey) => {
+  return useQuery29({
+    queryKey: [QueryConstants.GetFeatures, providerName, providerKey],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield FeaturesService.featuresGet(providerName, providerKey);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useAssignableRoles.ts
+import { useQuery as useQuery30 } from "@tanstack/react-query";
+import { UserService as UserService2 } from "@geowiki/api-proxy";
+var useAssignableRoles = () => {
+  return useQuery30({
+    queryKey: [QueryConstants.GetAssignableRoles],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield UserService2.userGetAssignableRoles();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useUserRoles.ts
+import { UserService as UserService3 } from "@geowiki/api-proxy";
+import { useQuery as useQuery31 } from "@tanstack/react-query";
+var useUserRoles = ({ userId }) => {
+  return useQuery31({
+    queryKey: [QueryConstants.GetUserRoles, userId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield UserService3.userGetRoles(userId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/usePermissions.ts
+import {
+  PermissionsService
+} from "@geowiki/api-proxy";
+import { useQuery as useQuery32 } from "@tanstack/react-query";
+var usePermissions = (providerName, providerKey) => {
+  return useQuery32({
+    queryKey: [QueryConstants.GetPermissions, providerName, providerKey],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield PermissionsService.permissionsGet(
+        providerName,
+        providerKey
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useRoles.ts
+import { useQuery as useQuery33 } from "@tanstack/react-query";
+import { RoleService } from "@geowiki/api-proxy";
+var useRoles = (pageIndex, pageSize, filter, sorting) => {
+  return useQuery33({
+    queryKey: [QueryConstants.GetRoles, pageIndex, pageSize, filter, sorting],
+    queryFn: () => __async(void 0, null, function* () {
+      let skip = 0;
+      if (pageIndex > 0) {
+        skip = pageIndex * pageSize;
+      }
+      const data = yield RoleService.roleGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useProfile.ts
+import { ProfileService as ProfileService2 } from "@geowiki/api-proxy";
+import { useQuery as useQuery34 } from "@tanstack/react-query";
+var useProfile = () => {
+  return useQuery34({
+    queryKey: [QueryConstants.GetProfile],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ProfileService2.profileGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useTenants.ts
+import { useQuery as useQuery35 } from "@tanstack/react-query";
+import { TenantService } from "@geowiki/api-proxy";
+var useTenants = (pageIndex, pageSize, filter, sorting) => {
+  return useQuery35({
+    queryKey: [QueryConstants.GetTenants, pageIndex, pageSize, filter, sorting],
+    queryFn: () => __async(void 0, null, function* () {
+      let skip = 0;
+      if (pageIndex > 0) {
+        skip = pageIndex * pageSize;
+      }
+      const data = yield TenantService.tenantGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useEvolandLabels.ts
+import { useQuery as useQuery36 } from "@tanstack/react-query";
+import { ProjectService as ProjectService3 } from "@geowiki/evoland-api-proxy";
+var useEvolandLabels = (projectId) => {
+  return useQuery36({
+    queryKey: [QueryNames.GetEvolandLabels, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ProjectService3.getLabelsLabelsProjectIdProjectIdGet(projectId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useLookUp.ts
+import { useQuery as useQuery37 } from "@tanstack/react-query";
+import { ClusterService as ClusterService6 } from "@geowiki/api-proxy";
+var useLookUp = (ServiceName, params, LookUpsClusterCountries, LookUpsClusterActivityStatus, LookUpsClusterFarmingSystem, LookUpsClusterMainAgricultureArea, LookUpsClusterMainCrops) => {
+  let result;
+  return useQuery37({
+    queryKey: [QueryNames.GetLookUp, ServiceName, params],
+    queryFn: () => __async(void 0, null, function* () {
+      switch (ServiceName) {
+        case LookUpsClusterCountries: {
+          result = yield ClusterService6.clusterGetCountries(params);
+          break;
+        }
+        case LookUpsClusterActivityStatus: {
+          result = yield ClusterService6.clusterGetActivityStatus(params);
+          break;
+        }
+        case LookUpsClusterFarmingSystem: {
+          result = yield ClusterService6.clusterGetFarmingSystems(params);
+          break;
+        }
+        case LookUpsClusterMainAgricultureArea: {
+          result = yield ClusterService6.clusterGetMainAgriculturalAreas(params);
+          break;
+        }
+        case LookUpsClusterMainCrops: {
+          result = yield ClusterService6.clusterGetMainCrops(params);
+          break;
+        }
+      }
+      return result;
+    })
+  });
+};
+
+// src/hooks/useProjects.ts
+import { useQuery as useQuery38, keepPreviousData as keepPreviousData7 } from "@tanstack/react-query";
+import {
+  ProjectService as ProjectService4,
+  TaskService,
+  TaskStatus,
+  StatisticService,
+  QuestionService
+} from "@geowiki/evoland-api-proxy";
+var useProjects = (fetch2, start = 0, amount = 9) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetProjects, fetch2, start, amount],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetch2)
+        return ProjectService4.listProjectsListprojectsStartidxStartidxAmountAmountGet(
+          start,
+          amount
+        );
+    })
+  });
+};
+var useProjectDetails = (projectId, update) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetProjectDetails, projectId, update],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.projectInfoProjectinfoProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTasksPerLocation = (data) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTasksPerLocation, data],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.getTasksTasksGet(
+        data.locationProjectId,
+        data.taskForReview,
+        null,
+        data.orderBy,
+        data.search,
+        TaskStatus[data.status],
+        null,
+        null,
+        null,
+        data.pageIdx,
+        data.pageSize,
+        data.userId,
+        data.userUserAlias,
+        data.userOrderBy,
+        data.locationLocationId,
+        data.locationOrderBy,
+        data.groupName,
+        data.groupOrderBy
+      );
+    }),
+    placeholderData: keepPreviousData7
+  });
+};
+var useRandomTasksPerLocation = (data) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTasksPerLocation, data],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.getRandomTaskRandomtaskGet(
+        data.locationProjectId,
+        data.taskForReview,
+        null,
+        data.orderBy == "" ? null : data.orderBy,
+        data.search == "" ? null : data.search,
+        TaskStatus[data.status],
+        data.statusIn == "" ? null : data.statusIn,
+        data.dateLte == "" ? null : data.dateLte,
+        data.dateGte == "" ? null : data.dateGte,
+        data.pageIdx,
+        data.pageSize,
+        data.userId == "" ? null : data.userId,
+        data.userUserAlias == "" ? null : data.userUserAlias,
+        data.userOrderBy == "" ? null : data.userOrderBy,
+        data.locationLocationId == "" ? null : data.locationLocationId,
+        data.locationOrderBy == "" ? null : data.locationOrderBy,
+        data.groupName == "" ? null : data.groupName
+      );
+    }),
+    placeholderData: keepPreviousData7
+  });
+};
+var useTaskComments = (taskIds) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskComment, taskIds],
+    queryFn: () => __async(void 0, null, function* () {
+      return TaskService.taskLatestComomentsTasklatestcommentPost({
+        task_ids: taskIds
+      });
+    })
+  });
+};
+var useGroupsInProject = (projectId, updateGroup) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetGroupsInProject, projectId, updateGroup],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.getProjectGroupsProjectgroupsProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useProjectUsers = (projectId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetProjectUsers, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.projectAllUsersProjectusersProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTaskStatusList = () => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskStatusList],
+    queryFn: () => __async(void 0, null, function* () {
+      return TaskService.getTaskStatusesTaskstatusesGet();
+    })
+  });
+};
+var useUpdateActiveGroupInProject = (projectId, groupId, update) => {
+  return useQuery38({
+    queryKey: [
+      QueryConstants.UpdateActiveGroupsInProject,
+      projectId,
+      groupId,
+      update
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return ProjectService4.selectProjectGroupProjectselectgroupPost({
+          project_id: projectId,
+          group_id: groupId
+        });
+    })
+  });
+};
+var useTaskAnnotation = (taskId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskAnnotation, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return TaskService.getTaskAnnotationAssetTaskannotationTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskMultipleAnnotations = (taskId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskMultipleAnnotations, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return TaskService.getTaskAnnotationAssetsTaskannotationsTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskSavedAnnotations = (taskId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskSavedAnnotations, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return TaskService.getSavedAnnotationGetsavedannotationTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskDelete = (taskId, projectId, deleteTask) => {
+  return useQuery38({
+    queryKey: [QueryConstants.DeleteTask, taskId, projectId, deleteTask],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== void 0 && taskId !== 0 && deleteTask === true)
+        return TaskService.deleteTaskDeletetaskPost({
+          project_id: projectId,
+          task_id: taskId
+        });
+    })
+  });
+};
+var useProjectStatisticsByUser = (projectId, startDate, endDate, filterUserId) => {
+  return useQuery38({
+    queryKey: [
+      QueryConstants.GetProjectStatisticsByUser,
+      projectId,
+      startDate,
+      endDate,
+      filterUserId
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return StatisticService.getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdGet(
+        projectId,
+        endDate,
+        startDate,
+        filterUserId
+      );
+    })
+  });
+};
+var useContractStatisticsByUser = (projectId, startDate, endDate, filterUserId) => {
+  return useQuery38({
+    queryKey: [
+      QueryConstants.GetContractStatisticsByUser,
+      projectId,
+      startDate,
+      endDate,
+      filterUserId
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return StatisticService.getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdGet(
+        projectId,
+        endDate,
+        startDate,
+        filterUserId,
+        true
+      );
+    })
+  });
+};
+var useLatestTaskOnLocation = (locationId, projectId, referenceDate) => {
+  return useQuery38({
+    queryKey: [
+      QueryConstants.GetLatestTaskOnLocation,
+      locationId,
+      projectId,
+      referenceDate
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.locationLatestTaskLocationtaskLocationIdLocationIdProjectIdProjectIdReferenceDateReferenceDateGet(
+        locationId,
+        projectId,
+        referenceDate
+      );
+    })
+  });
+};
+var useAssignProjectToUser = (userRoleRequest, update) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetProjectDetails, userRoleRequest, update],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return ProjectService4.setUserRoleSetuserrolePost(userRoleRequest);
+    }),
+    enabled: !!update && !!userRoleRequest
+  });
+};
+var useGetUserProject = (user_id, fetchData) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetUserProject, user_id, fetchData],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetchData)
+        return ProjectService4.getUserRoleProjectGetuserroleprojectUserIdUserIdGet(
+          user_id
+        );
+    })
+  });
+};
+var useUpdateUserDetail = (userDetailRequest, update) => {
+  return useQuery38({
+    queryKey: [QueryConstants.SetUserDetail, userDetailRequest, update],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return ProjectService4.setUserDetailSetuserdetailPost(userDetailRequest);
+    })
+  });
+};
+var useProjectsPointsDownload = (projectId, download, userRole) => {
+  return useQuery38({
+    queryKey: [
+      QueryConstants.DownlaodProjectsPoints,
+      projectId,
+      download,
+      userRole
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      if (userRole == "admin" && download)
+        return ProjectService4.getLocationsSummaryLocationssummaryProjectIdProjectIdGet(
+          projectId
+        );
+    })
+  });
+};
+var useQuestionnaire = (projectId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetQuestionnaireForProject, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      return QuestionService.getProjectQuestionsAnswersQuestionsAnswersProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTaskAnswers = (taskId) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetTaskAnswers, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      return TaskService.getTaskAnswersTaskanswersTaskIdTaskIdGet(taskId);
+    })
+  });
+};
+var useProjectResultSet = (download, projectId, is_geo_json) => {
+  return useQuery38({
+    queryKey: [QueryConstants.GetProjectResultSet, download, projectId, is_geo_json],
+    queryFn: () => __async(void 0, null, function* () {
+      return ProjectService4.projectResultSetProjectresultsetProjectIdProjectIdIsGeoJsonIsGeoJsonGet(projectId, is_geo_json);
+    }),
+    enabled: !!download && !!projectId
+  });
+};
+
+// src/hooks/useApiImage.tsx
+import { useQuery as useQuery39 } from "@tanstack/react-query";
+var useApiImage = (imageId) => {
+  return useQuery39({
+    queryKey: [QueryConstants.GetApiImage, imageId],
+    queryFn: () => __async(void 0, null, function* () {
+      const res = yield fetch(`/api/api-image/${imageId}`);
+      const data = yield res.json();
+      return data.fileUrl;
+    })
+  });
+};
+
+// src/hooks/useCmsImage.tsx
+import { useQuery as useQuery40 } from "@tanstack/react-query";
+var useCmsImage = (imageId) => {
+  return useQuery40({
+    queryKey: [QueryConstants.GetCmsImage, imageId],
+    queryFn: () => __async(void 0, null, function* () {
+      const res = yield fetch(`/api/cms-image/${imageId}`);
+      const data = yield res.json();
+      return data.fileUrl;
+    })
+  });
+};
+
+// src/hooks/useClusterGetJoinRequests.ts
+import { ClusterService as ClusterService7 } from "@geowiki/api-proxy";
+import { useQuery as useQuery41 } from "@tanstack/react-query";
+var useClusterGetJoinRequests = (clusterId) => {
+  return useQuery41({
+    queryKey: [QueryNames.JoinRequests, clusterId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService7.clusterGetJoinRequests(clusterId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterGetNews.ts
+import { ClusterService as ClusterService8 } from "@geowiki/api-proxy";
+import { useQuery as useQuery42 } from "@tanstack/react-query";
+var useClusterGetNews = (clusterId, newsId) => {
+  return useQuery42({
+    queryKey: [QueryNames.ClusterGetNews, clusterId, newsId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService8.clusterGetNews(clusterId, newsId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterGetNewsNextPreviousStatus.ts
+import { ClusterService as ClusterService9 } from "@geowiki/api-proxy";
+import { useQuery as useQuery43 } from "@tanstack/react-query";
+var useClusterGetNewsNextPreviousStatus = (clusterId, newsId) => {
+  return useQuery43({
+    queryKey: [QueryNames.ClusterNewsNextPrevious, clusterId, newsId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService9.clusterGetNewsNextPreviousStatus(
+        clusterId,
+        newsId
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterImages.ts
+import { ClusterService as ClusterService10 } from "@geowiki/api-proxy";
+import { useQuery as useQuery44 } from "@tanstack/react-query";
+var useClusterImages = (id) => {
+  return useQuery44({
+    queryKey: [QueryNames.ClusterImages, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService10.clusterGetClusterImages(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterOverview.ts
+import { ClusterService as ClusterService11 } from "@geowiki/api-proxy";
+import { useQuery as useQuery45 } from "@tanstack/react-query";
+var useClusterOverview = (id) => {
+  return useQuery45({
+    queryKey: [QueryNames.GetClusterOverview, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService11.clusterGetClusterOverview(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterAllNews.ts
+import { ClusterService as ClusterService12 } from "@geowiki/api-proxy";
+import { useQuery as useQuery46 } from "@tanstack/react-query";
+var useClusterAllNews = (id, refresh, sorting, skipCount, maxResultCount, status) => {
+  return useQuery46({
+    queryKey: [
+      QueryNames.ClusterAllNews,
+      id,
+      sorting,
+      skipCount,
+      maxResultCount,
+      refresh,
+      status
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService12.clusterGetAllNews(
+        id,
+        sorting,
+        skipCount,
+        maxResultCount,
+        status
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useNewsFromAllClusters.ts
+import { ClusterService as ClusterService13 } from "@geowiki/api-proxy";
+import { useQuery as useQuery47 } from "@tanstack/react-query";
+var useNewsFromAllClusters = (skip = 0, take = 10) => {
+  return useQuery47({
+    queryKey: [QueryNames.ClusterAllNews, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService13.clusterGetAllNewsFromAllClusters(
+        "",
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterNewsWithId.ts
+import { ClusterService as ClusterService14 } from "@geowiki/api-proxy";
+import { useQuery as useQuery48 } from "@tanstack/react-query";
+var useClusterNewsWithId = (id) => {
+  return useQuery48({
+    queryKey: [QueryNames.ClusterNewsWithId, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService14.clusterGetClusterNewsById(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useMapMenuItems.ts
+import { useQuery as useQuery49 } from "@tanstack/react-query";
+
+// src/utils/CmsApi.ts
+import {
+  QueryApiService,
+  SettingsService as SettingsService7
+} from "@geowiki/cms-proxy";
+var getGeoWikiSettings = () => __async(void 0, null, function* () {
+  const req = yield SettingsService7.settingsGetSiteSettings("GeoWiki");
+  return req;
+});
+var getDefaultSettings = () => __async(void 0, null, function* () {
+  const req = yield SettingsService7.settingsGetDefaultSiteSettings();
+  return req;
+});
+var getMenus = (displayName) => __async(void 0, null, function* () {
+  const req = yield getContentWithTypeAndDisplayName(
+    "Menu",
+    displayName
+  );
+  const menus = req == null ? void 0 : req.items[0];
+  return menus;
+});
+var getPageContent = (displayName) => __async(void 0, null, function* () {
+  const req = yield getContentWithTypeAndDisplayName(
+    "Page",
+    displayName
+  );
+  const page = req == null ? void 0 : req.items[0];
+  return page;
+});
+var getContentWithTypeAndDisplayName = (contentType, displayName) => __async(void 0, null, function* () {
+  return QueryApiService.apiQueryGet(
+    "GetContentByTypeAndDisplayText",
+    `${JSON.stringify({ contenttype: contentType, displaytext: displayName })}`
+  );
+});
+var getContentWithSlug = (slug) => __async(void 0, null, function* () {
+  const req = yield QueryApiService.apiQueryGet(
+    "GetDocumentBySlug",
+    `${JSON.stringify({ path: slug })}`
+  );
+  return req == null ? void 0 : req.items[0];
+});
+var getContentsWithType = (contentType) => __async(void 0, null, function* () {
+  const req = yield QueryApiService.apiQueryGet(
+    "GetContentByType",
+    `${JSON.stringify({ contenttype: contentType })}`
+  );
+  return req == null ? void 0 : req.items;
+});
+var getPageProps = (ctx) => __async(void 0, null, function* () {
+  var _a;
+  var page = "index";
+  const slugs = ctx.query.slug;
+  if (slugs && slugs.length > 0) {
+    page = slugs[slugs.length - 1];
+  }
+  return {
+    props: {
+      page: (_a = yield getPageContent(page)) != null ? _a : null
+    }
+  };
+});
+
+// src/hooks/useMapMenuItems.ts
+var useMapMenuItems = () => {
+  return useQuery49({
+    queryKey: [QueryNames.MapMenuItems],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield getContentsWithType("MapMenuItem");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterLinks.ts
+import { ClusterService as ClusterService15 } from "@geowiki/api-proxy";
+import { useQuery as useQuery50 } from "@tanstack/react-query";
+var useClusterLinks = (id) => {
+  return useQuery50({
+    queryKey: [QueryNames.GetSocialLinks, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService15.clusterGetLinksAndPartner(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useCmsContentWithType.ts
+import { useQuery as useQuery51 } from "@tanstack/react-query";
+var useCmsContentWithType = (contentType) => {
+  return useQuery51({
+    queryKey: [QueryNames.GetCmsContentWithType],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield getContentsWithType(contentType);
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterNews.ts
+import { ClusterService as ClusterService16 } from "@geowiki/api-proxy";
+import { useQuery as useQuery52 } from "@tanstack/react-query";
+var useClusterNews = (id, sort = "", skip = 0, take = 100) => {
+  return useQuery52({
+    queryKey: [QueryNames.ClusterNews, id, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService16.clusterGetClusterNews(
+        id,
+        sort,
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterDescription.ts
+import { ClusterService as ClusterService17 } from "@geowiki/api-proxy";
+import { useQuery as useQuery53 } from "@tanstack/react-query";
+var useClusterDescription = (id) => {
+  return useQuery53({
+    queryKey: [QueryNames.GetClusterDescription, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService17.clusterGetClusterDescription(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterDetails.ts
+import { ClusterService as ClusterService18 } from "@geowiki/api-proxy";
+import { useQuery as useQuery54 } from "@tanstack/react-query";
+var useClusterDetails = (id) => {
+  return useQuery54({
+    queryKey: [QueryNames.GetClusterDetails, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService18.clusterGetClusterDetails(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterImagesAndVideos.ts
+import { ClusterService as ClusterService19 } from "@geowiki/api-proxy";
+import { useQuery as useQuery55 } from "@tanstack/react-query";
+var useClusterImagesAndVideos = (id) => {
+  return useQuery55({
+    queryKey: [QueryNames.GetImagesAndVideos, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield ClusterService19.clusterGetImagesAndVideos(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useHost.ts
+import { useQuery as useQuery56 } from "@tanstack/react-query";
+var getHost = () => __async(void 0, null, function* () {
+  const response = yield fetch("/api/host");
+  if (!response.ok) {
+    return Promise.reject(null);
+  }
+  return response.json();
+});
+function useHost() {
+  return useQuery56({
+    queryKey: [QueryNames.GetHost],
+    queryFn: getHost
+  });
+}
+
+// src/hooks/useHostManagement.ts
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+var createHost = (hostData) => __async(void 0, null, function* () {
+  const response = yield fetch("/api/hosts", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(hostData)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to create host");
+  }
+  return response.json();
+});
+var updateHost = (_a) => __async(void 0, null, function* () {
+  var _b = _a, {
+    host
+  } = _b, hostData = __objRest(_b, [
+    "host"
+  ]);
+  const response = yield fetch(`/api/hosts/${host}`, {
+    method: "PUT",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(hostData)
+  });
+  if (!response.ok) {
+    throw new Error("Failed to update host");
+  }
+  return response.json();
+});
+var deleteHost = (host) => __async(void 0, null, function* () {
+  const response = yield fetch(`/api/hosts/${host}`, {
+    method: "DELETE"
+  });
+  if (!response.ok) {
+    throw new Error("Failed to delete host");
+  }
+});
+var useCreateHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: createHost,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHosts] });
+    }
+  });
+};
+var useUpdateHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: updateHost,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHosts] });
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHost] });
+    }
+  });
+};
+var useDeleteHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: deleteHost,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHosts] });
+    }
+  });
+};
+
+// src/models/HostInfo.ts
+var HostType = /* @__PURE__ */ ((HostType2) => {
+  HostType2["IsActive"] = "IsActive";
+  HostType2["IsUnderConstruction"] = "IsUnderConstruction";
+  return HostType2;
+})(HostType || {});
+
+// src/utils/ServerHostUtils.ts
+var getHostData = () => {
+  return process.env.NODE_ENV === "production" ? [
+    {
+      host: "v2.geo-wiki.org",
+      cmsUrl: "https://cms.main.geo-wiki.org"
+    },
+    {
+      host: "evo.geo-wiki.org",
+      cmsUrl: "https://cms.main.geo-wiki.org/evoland",
+      tenantId: "3a12f4a0-c86a-d6fc-ec94-910ebeb86aea",
+      redirectUrl: "/evoland/projects"
+    },
+    {
+      host: "evo-dev.main.geo-wiki.org",
+      cmsUrl: "https://cms.main.geo-wiki.org/evoland-dev",
+      tenantId: "3a0d5d86-5eac-0234-6d1c-eeecdd06739d",
+      redirectUrl: "/evoland/projects"
+    },
+    {
+      host: "recodo.geo-wiki.org",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "frameworkv2.geo-wiki.org",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "geo-wiki.org",
+      cmsUrl: "https://cms.main.geo-wiki.org",
+      tenantId: "39fdc097-fa0e-aa99-6ec9-a387d3225abc"
+    },
+    {
+      host: "geowiki.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org",
+      tenantId: "39fdc097-fa0e-aa99-6ec9-a387d3225abc"
+    },
+    {
+      host: "web.geowiki.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org",
+      tenantId: "39fdc097-fa0e-aa99-6ec9-a387d3225abc"
+    },
+    {
+      host: "www.geo-wiki.org",
+      cmsUrl: "https://cms.main.geo-wiki.org",
+      tenantId: "39fdc097-fa0e-aa99-6ec9-a387d3225abc"
+    },
+    {
+      host: "recodo.io",
+      cmsUrl: "https://cms.geo-wiki.org/recodo",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/admin/cluster"
+    },
+    {
+      host: "recodo.iiasa.ac.at",
+      cmsUrl: "https://cms.geo-wiki.org/recodo",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "framework.geo-wiki.org",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "recodo.nodes.iiasa.ac.at",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/admin/cluster"
+    },
+    {
+      host: "hpg1025.iiasa.ac.at:31028",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "demo.geo-wiki.org",
+      cmsUrl: "https://demo.cms.geo-wiki.org"
+    },
+    {
+      host: "mindstep.geo-wiki.org",
+      cmsUrl: "https://mindstep.cms.geo-wiki.org"
+    },
+    {
+      host: "tm.geo-wiki.org",
+      cmsUrl: "https://tm.cms.geo-wiki.org"
+    },
+    {
+      host: "cropobserve.org",
+      cmsUrl: "https://cropobserve.cms.geo-wiki.org"
+    },
+    {
+      host: "localhost:3000",
+      cmsUrl: "https://cms.main.geo-wiki.org"
+    },
+    {
+      host: "localhost:4000",
+      cmsUrl: "https://cms.main.geo-wiki.org"
+    },
+    {
+      host: "adapt-uhi.org",
+      cmsUrl: "https://cms.main.geo-wiki.org/adapt"
+    },
+    {
+      host: "geo-trees.nodes.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org/geotrees",
+      tenantId: "3a12f511-0804-948c-db52-a33491c51e48",
+      redirectUrl: "/"
+    },
+    {
+      host: "globalcanopyatlas.org",
+      cmsUrl: "https://cms.geowiki.iiasa.ac.at/canopyatlas",
+      tenantId: "3a1481ec-90a1-47d0-c34d-70610f97a4e5",
+      redirectUrl: "/",
+      protectedPaths: ["/map"]
+    },
+    {
+      host: "canopyatlas.nodes.iiasa.ac.at",
+      cmsUrl: "https://cms.geowiki.iiasa.ac.at/canopyatlas",
+      tenantId: "3a1481ec-90a1-47d0-c34d-70610f97a4e5",
+      redirectUrl: "/",
+      protectedPaths: ["/map"]
+    },
+    {
+      host: "basf.nodes.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org/basf",
+      tenantId: "3a16570a-6c13-db58-25f7-1866c09412b7",
+      redirectUrl: "/",
+      protectedPaths: ["/map"]
+    },
+    {
+      host: "evo.nodes.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org/evoland-dev",
+      tenantId: "3a0d5d86-5eac-0234-6d1c-eeecdd06739d",
+      redirectUrl: "/evoland/projects"
+    },
+    {
+      host: "urbanreleaf.nodes.iiasa.ac.at",
+      cmsUrl: "https://cms.main.geo-wiki.org/urbanreleaf",
+      redirectUrl: "/"
+    },
+    {
+      host: "geoquest.iiasa.ac.at",
+      cmsUrl: "https://cms.geowiki.iiasa.ac.at/geoquest",
+      redirectUrl: "/"
+    },
+    {
+      host: "geo-quest.org",
+      cmsUrl: "https://cms.geowiki.iiasa.ac.at/geoquest",
+      redirectUrl: "/"
+    },
+    {
+      host: "data.geo-trees.org",
+      cmsUrl: "https://cms.main.geo-wiki.org/geotrees",
+      tenantId: "3a1a9007-e328-c293-e501-472a18594650",
+      redirectUrl: "/"
+    }
+  ] : [
+    {
+      host: "localhost:3000",
+      cmsUrl: "https://framework.cms.geo-wiki.org",
+      tenantId: "39fdc096-4274-dfe4-1761-03d8f52219a5",
+      redirectUrl: "/page/user/user-profile"
+    },
+    {
+      host: "geowiki.local:3000",
+      cmsUrl: "https://cms.main.geo-wiki.org"
+    },
+    {
+      host: "recodo.local:3000",
+      cmsUrl: "https://framework.cms.geo-wiki.org"
+    },
+    {
+      host: "evo.local:3000",
+      cmsUrl: "https://cms.main.geo-wiki.org/evoland",
+      tenantId: "3a0d5d86-5eac-0234-6d1c-eeecdd06739d",
+      redirectUrl: "/evoland/projects"
+    }
+  ];
+};
+var findHostInfo = (host) => {
+  const hosts = getHostData();
+  return hosts.find((h) => h.host === host);
+};
+var getCmsUrlForHost = (host) => {
+  const hostInfo = findHostInfo(host);
+  return (hostInfo == null ? void 0 : hostInfo.cmsUrl) || "https://cms.geo-wiki.org";
+};
+var getTenantIdForHost = (host) => {
+  const hostInfo = findHostInfo(host);
+  return hostInfo == null ? void 0 : hostInfo.tenantId;
+};
+
+// src/services/HostService.ts
+var HostService = class {
+  /**
+   * Server-side: Get all hosts data
+   * This should be used in API routes and server-side code
+   */
+  static getHostData() {
+    return getHostData();
+  }
+  /**
+   * Server-side: Find host info by hostname
+   * This should be used in API routes and server-side code
+   */
+  static findHostInfo(host) {
+    return findHostInfo(host);
+  }
+  /**
+   * Server-side: Get CMS URL for a specific host
+   * This should be used in API routes and server-side code
+   */
+  static getCmsUrlForHost(host) {
+    return getCmsUrlForHost(host);
+  }
+  /**
+   * Server-side: Get tenant ID for a specific host
+   * This should be used in API routes and server-side code
+   */
+  static getTenantIdForHost(host) {
+    return getTenantIdForHost(host);
+  }
+  /**
+   * Utility: Check if host is under construction
+   */
+  static isHostUnderConstruction(hostInfo) {
+    return (hostInfo == null ? void 0 : hostInfo.hostType) === "IsUnderConstruction" /* IsUnderConstruction */;
+  }
+  /**
+   * Utility: Check if host has protected paths
+   */
+  static hasProtectedPaths(hostInfo) {
+    return Boolean(
+      (hostInfo == null ? void 0 : hostInfo.protectedPaths) && hostInfo.protectedPaths.length > 0
+    );
+  }
+  /**
+   * Utility: Check if a path is protected for a host
+   */
+  static isPathProtected(hostInfo, path) {
+    if (!(hostInfo == null ? void 0 : hostInfo.protectedPaths))
+      return false;
+    return hostInfo.protectedPaths.some(
+      (protectedPath) => path.startsWith(protectedPath)
+    );
+  }
+  /**
+   * Utility: Get redirect URL for host
+   */
+  static getRedirectUrl(hostInfo) {
+    return hostInfo == null ? void 0 : hostInfo.redirectUrl;
+  }
+  /**
+   * Utility: Get tenant name from host info
+   */
+  static getTenantName(hostInfo) {
+    return hostInfo == null ? void 0 : hostInfo.name;
+  }
+  /**
+   * Utility: Validate host configuration
+   */
+  static validateHostInfo(hostInfo) {
+    const errors = [];
+    if (!hostInfo.host) {
+      errors.push("Host is required");
+    }
+    if (!hostInfo.cmsUrl) {
+      errors.push("CMS URL is required");
+    }
+    if (hostInfo.cmsUrl && !this.isValidUrl(hostInfo.cmsUrl)) {
+      errors.push("CMS URL must be a valid URL");
+    }
+    if (hostInfo.redirectUrl && !this.isValidPath(hostInfo.redirectUrl)) {
+      errors.push("Redirect URL must be a valid path");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Utility: Check if URL is valid
+   */
+  static isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Utility: Check if path is valid
+   */
+  static isValidPath(path) {
+    return path.startsWith("/") || path.startsWith("http");
+  }
+  /**
+   * Utility: Get host info for current window location (client-side only)
+   */
+  static getCurrentHostInfo(hosts) {
+    if (typeof window === "undefined")
+      return void 0;
+    return hosts.find((h) => h.host === window.location.host);
+  }
+  /**
+   * Utility: Get host info for specific hostname from hosts array
+   */
+  static getHostInfoFromArray(hosts, hostname) {
+    return hosts.find((h) => h.host === hostname);
+  }
+  /**
+   * Utility: Filter hosts by tenant ID
+   */
+  static filterHostsByTenant(hosts, tenantId) {
+    return hosts.filter((h) => h.tenantId === tenantId);
+  }
+  /**
+   * Utility: Filter hosts by CMS URL
+   */
+  static filterHostsByCmsUrl(hosts, cmsUrl) {
+    return hosts.filter((h) => h.cmsUrl === cmsUrl);
+  }
+  /**
+   * Utility: Get unique tenant IDs from hosts
+   */
+  static getUniqueTenantIds(hosts) {
+    const tenantIds = hosts.map((h) => h.tenantId).filter((id) => Boolean(id));
+    return [...new Set(tenantIds)];
+  }
+  /**
+   * Utility: Get unique CMS URLs from hosts
+   */
+  static getUniqueCmsUrls(hosts) {
+    const cmsUrls = hosts.map((h) => h.cmsUrl);
+    return [...new Set(cmsUrls)];
+  }
+};
+
+// src/models/ButtonType.ts
+var StyleType = /* @__PURE__ */ ((StyleType2) => {
+  StyleType2[StyleType2["Primary"] = 0] = "Primary";
+  StyleType2[StyleType2["Secondary"] = 1] = "Secondary";
+  StyleType2[StyleType2["Success"] = 2] = "Success";
+  StyleType2[StyleType2["Danger"] = 3] = "Danger";
+  StyleType2[StyleType2["Warning"] = 4] = "Warning";
+  StyleType2[StyleType2["Info"] = 5] = "Info";
+  return StyleType2;
+})(StyleType || {});
+
+// src/models/ViewStatus.ts
+var ViewStatus = /* @__PURE__ */ ((ViewStatus2) => {
+  ViewStatus2[ViewStatus2["New"] = 0] = "New";
+  ViewStatus2[ViewStatus2["Edit"] = 1] = "Edit";
+  ViewStatus2[ViewStatus2["List"] = 2] = "List";
+  ViewStatus2[ViewStatus2["View"] = 3] = "View";
+  return ViewStatus2;
+})(ViewStatus || {});
+
+// src/models/TaskStatus.ts
+var TaskStatus2 = /* @__PURE__ */ ((TaskStatus3) => {
+  TaskStatus3["ASSIGNED"] = "ASSIGNED";
+  TaskStatus3["SKIPPED"] = "SKIPPED";
+  TaskStatus3["IN_REVIEW"] = "IN_REVIEW";
+  TaskStatus3["SUBMITTED"] = "SUBMITTED";
+  TaskStatus3["TO_FIX"] = "TO_FIX";
+  TaskStatus3["ACCEPTED"] = "ACCEPTED";
+  TaskStatus3["USER_DISCARDED"] = "USER_DISCARDED";
+  TaskStatus3["DISCARDED"] = "DISCARDED";
+  return TaskStatus3;
+})(TaskStatus2 || {});
+var TaskStatusColor = /* @__PURE__ */ ((TaskStatusColor2) => {
+  TaskStatusColor2["ASSIGNED"] = "goldenrod";
+  TaskStatusColor2["SKIPPED"] = "darkgray";
+  TaskStatusColor2["IN_REVIEW"] = "pink";
+  TaskStatusColor2["TO_FIX"] = "red";
+  TaskStatusColor2["ACCEPTED"] = "violet";
+  TaskStatusColor2["DISCARDED"] = "aqua";
+  TaskStatusColor2["SUBMITTED"] = "green";
+  TaskStatusColor2["USER_DISCARDED"] = "orange";
+  return TaskStatusColor2;
+})(TaskStatusColor || {});
+var TaskEventType = /* @__PURE__ */ ((TaskEventType2) => {
+  TaskEventType2["CREATED"] = "CREATED";
+  TaskEventType2["NEW_ANNOTATION"] = "NEW_ANNOTATION";
+  TaskEventType2["STATUS_UPDATED"] = "STATUS_UPDATED";
+  TaskEventType2["COMMENT"] = "COMMENT";
+  TaskEventType2["QUESTIONNAIRE"] = "QUESTIONNAIRE";
+  TaskEventType2["REVIEW"] = "REVIEW";
+  return TaskEventType2;
+})(TaskEventType || {});
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2["ASSIGNED"] = "Assigned";
+  TaskState2["SKIPPED"] = "Skip";
+  TaskState2["IN_REVIEW"] = "Ask to Review";
+  TaskState2["SUBMITTED"] = "Submit";
+  TaskState2["TO_FIX"] = "To Fix";
+  TaskState2["ACCEPTED"] = "Accept";
+  TaskState2["USER_DISCARDED"] = "Discard";
+  TaskState2["DISCARDED"] = "Discard";
+  return TaskState2;
+})(TaskState || {});
+var AnnotationRequired = /* @__PURE__ */ ((AnnotationRequired2) => {
+  AnnotationRequired2["NOT_REQUIRED"] = "NOT_REQUIRED";
+  AnnotationRequired2["REQUIRED"] = "REQUIRED";
+  AnnotationRequired2["OPTIONAL"] = "OPTIONAL";
+  return AnnotationRequired2;
+})(AnnotationRequired || {});
+var QuestionnaireType = /* @__PURE__ */ ((QuestionnaireType2) => {
+  QuestionnaireType2["TEXT"] = "TEXT";
+  QuestionnaireType2["CONTEXT"] = "CONTEXT";
+  QuestionnaireType2["SINGLE_CHOICE"] = "SINGLE_CHOICE";
+  QuestionnaireType2["MULTI_CHOICE"] = "MULTI_CHOICE";
+  QuestionnaireType2["DATETIME"] = "DATETIME";
+  return QuestionnaireType2;
+})(QuestionnaireType || {});
+
+// src/stores/breadCrumbs.ts
+import { create } from "zustand";
+var initialState = [];
+var useBreadCrumbStore = create()((set) => ({
+  breadCrumbs: initialState,
+  reset: () => set((state) => {
+    state.breadCrumbs.length = 1;
+    return { breadCrumbs: state.breadCrumbs };
+  }),
+  add: (breadCrumb) => set((state) => {
+    const mainArr = [].concat(
+      ...state.breadCrumbs.map((x) => x.path)
+    );
+    const currArr = [].concat(breadCrumb == null ? void 0 : breadCrumb.map((x) => x.path));
+    if (breadCrumb != null && mainArr.some((r) => currArr == null ? void 0 : currArr.includes(r)) == false) {
+      breadCrumb.forEach((element) => {
+        state.breadCrumbs.push(element);
+      });
+    } else {
+      var index = mainArr.findIndex(
+        (x) => x == currArr[currArr.length - 1]
+      );
+      state.breadCrumbs.length = index + 1;
+    }
+    return { breadCrumbs: state.breadCrumbs };
+  }),
+  remove: (breadCrumb) => set((state) => {
+    var index = state.breadCrumbs.findIndex(
+      (l) => (l == null ? void 0 : l.path) === breadCrumb.path
+    );
+    state.breadCrumbs.length = index + 1;
+    return { breadCrumbs: state.breadCrumbs };
+  })
+}));
+
+// src/stores/layers.ts
+import { create as create2 } from "zustand";
+var useLayerStore = create2()((set) => ({
+  layers: [],
+  add: (layer) => set((state) => {
+    state.layers.push(layer);
+    return { layers: state.layers };
+  }),
+  remove: (layer) => set((state) => {
+    var index = state.layers.findIndex(
+      (l) => l.ContentItemId === layer.ContentItemId
+    );
+    state.layers.splice(index, 1);
+    return { layers: state.layers };
+  })
+}));
+
+// src/stores/settings.ts
+import { createStore as createStore2 } from "zustand/vanilla";
+var settingsStore = createStore2(() => ({
+  settings: null
+}));
+
+// src/stores/panel.ts
+import { create as create3 } from "zustand";
+var usePanelStore = create3((set) => ({
+  isLeftPanelOpen: false,
+  setIsLeftPanelOpen: (isLeftPanelOpen) => set({ isLeftPanelOpen }),
+  isRightPanelOpen: false,
+  setIsRightPanelOpen: (isRightPanelOpen) => set({ isRightPanelOpen }),
+  panelRef: null,
+  setPanelRef: (panelRef) => set({ panelRef }),
+  showPanels: () => set((state) => {
+    return __spreadProps(__spreadValues({}, state), {
+      isLeftPanelOpen: true,
+      isRightPanelOpen: true
+    });
+  })
+}));
+
+// src/stores/basf.ts
+import { create as create4 } from "zustand";
+var useBasfStore = create4((set) => ({
+  selectedItems: [],
+  // addItem: (item) =>
+  //   set((state) => ({
+  //     selectedItems: [
+  //       ...state.selectedItems,
+  //       { ...item, opacity: 1, enabled: true },
+  //     ],
+  //     rightPanelOpen: true,
+  //   })),
+  addItem: (item) => set(() => ({
+    selectedItems: [__spreadProps(__spreadValues({}, item), { opacity: 1, enabled: true })],
+    rightPanelOpen: true
+  })),
+  removeItem: (id) => set((state) => ({
+    selectedItems: state.selectedItems.filter((item) => item.id !== id)
+  })),
+  updateItemOpacity: (id, opacity) => set((state) => ({
+    selectedItems: state.selectedItems.map(
+      (item) => item.id === id ? __spreadProps(__spreadValues({}, item), { opacity }) : item
+    )
+  })),
+  updateItemEnabled: (id, enabled) => set((state) => ({
+    selectedItems: state.selectedItems.map(
+      (item) => item.id === id ? __spreadProps(__spreadValues({}, item), { enabled }) : item
+    )
+  })),
+  rightPanelOpen: false,
+  leftPanelOpen: true,
+  updateRightPanelOpen: (open) => set({ rightPanelOpen: open }),
+  updateLeftPanelOpen: (open) => set({ leftPanelOpen: open })
+}));
+
+// src/utils/common.ts
+import { createRoot } from "react-dom/client";
+import { flushSync } from "react-dom";
+import { I18n } from "next-localization";
+import { driver } from "driver.js";
+import "driver.js/dist/driver.css";
+import * as XLSX from "xlsx";
+var i18n = I18n();
+var getHtmlElementFromReactNode = (node) => {
+  const div = document.createElement("div");
+  const root = createRoot(div);
+  queueMicrotask(() => {
+    flushSync(() => {
+      root.render(node);
+    });
+  });
+  return div;
+};
+var classNames = (...classes) => {
+  return classes.filter(Boolean).join(" ");
+};
+function getButtonAppearance(type, background) {
+  if (type === "primary") {
+    if (background === "light") {
+      return "dark";
+    }
+    return "white";
+  } else if (type === "secondary") {
+    if (background === "light") {
+      return "dark-outline";
+    }
+    return "white-outline";
+  }
+  return "dark";
+}
+function getMediaUrl(url) {
+  if (url == null) {
+    return "";
+  }
+  if (url.startsWith("http") || url.startsWith("//")) {
+    return url;
+  }
+}
+var showIntroTour = (tourSteps) => {
+  const driverObj = driver({
+    showProgress: true,
+    showButtons: ["next", "previous", "close"],
+    steps: tourSteps
+  });
+  setTimeout(() => {
+    driverObj.drive();
+  }, 100);
+};
+var tokenData = (token, field) => {
+  try {
+    return JSON.parse(
+      window.atob(
+        token !== void 0 ? token.split(".")[1].replace("-", "+").replace("_", "/") : ""
+      )
+    )[field];
+  } catch (e) {
+    console.error("Invalid JSON : ", e);
+  }
+};
+var IsTokenExpired = (tokenExpires) => {
+  try {
+    if (tokenExpires)
+      return new Date(tokenExpires).valueOf() < Date.now().valueOf();
+  } catch (e) {
+    console.log("Invlaid token to check expiry : ", e);
+  }
+};
+var getHostFromRequest = (req) => {
+  let host = req.headers.host;
+  if (!host) {
+    host = window.location.host;
+    if (!host) {
+      throw new Error("Host not found");
+    }
+  }
+  if (host == null ? void 0 : host.startsWith("hpg1025")) {
+    const forwardedHost = req == null ? void 0 : req.headers["x-forwarded-host"];
+    if (forwardedHost) {
+      host = forwardedHost;
+    }
+  }
+  return host;
+};
+var shimmer = (w, h) => `
+<svg width="${w}" height="${h}" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+  <defs>
+    <linearGradient id="g">
+      <stop stop-color="#333" offset="20%" />
+      <stop stop-color="#222" offset="50%" />
+      <stop stop-color="#333" offset="70%" />
+    </linearGradient>
+  </defs>
+  <rect width="${w}" height="${h}" fill="#333" />
+  <rect id="r" width="${w}" height="${h}" fill="url(#g)" />
+  <animate xlink:href="#r" attributeName="x" from="-${w}" to="${w}" dur="1s" repeatCount="indefinite"  />
+</svg>`;
+var toBase64 = (str) => typeof window === "undefined" ? Buffer.from(str).toString("base64") : window.btoa(str);
+var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+var triplet = (e1, e2, e3) => keyStr.charAt(e1 >> 2) + keyStr.charAt((e1 & 3) << 4 | e2 >> 4) + keyStr.charAt((e2 & 15) << 2 | e3 >> 6) + keyStr.charAt(e3 & 63);
+var rgbDataURL = (r, g, b) => `data:image/gif;base64,R0lGODlhAQABAPAA${triplet(0, r, g) + triplet(b, 255, 255)}/yH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==`;
+var downloadData = (data, fileName) => {
+  const worksheet = XLSX.utils.json_to_sheet(data);
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, "Sheet1");
+  XLSX.writeFile(workbook, fileName);
+};
+var scrollToFirstErrorElement = (errors) => {
+  const errorsValues = Object.values(errors);
+  console.log(errorsValues);
+  if (errorsValues.length > 0) {
+    var elements = Object.keys(errors).map((name) => document.getElementsByName(name)[0]).filter((x) => x !== void 0);
+    if (elements.length === 0) {
+      var selectors = Object.keys(errors).map(
+        (name) => `[data-name="${name}"]`
+      );
+      var dataElements = selectors.map((selector) => document.querySelectorAll(selector)[0]).filter((x) => x !== void 0 && x !== null);
+      if (dataElements.length > 0) {
+        dataElements[0].scrollIntoView({
+          behavior: "smooth",
+          block: "center",
+          inline: "center"
+        });
+      }
+    }
+  }
+};
+var downloadJSON = (data, fileName) => {
+  const jsonString = JSON.stringify(data);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = fileName;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+};
+var formatUnixDate = (date) => {
+  const dateObj = new Date(date);
+  const year = dateObj.getFullYear();
+  const month = String(dateObj.getMonth() + 1).padStart(2, "0");
+  const day = String(dateObj.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+};
+
+// src/utils/Config.ts
+import { HomeIcon, UserIcon, WrenchIcon } from "@heroicons/react/24/outline";
+var Config = {
+  site_name: "Geo-Wiki",
+  title: "Geo-Wiki",
+  description: "Geo-Wiki",
+  locale: "en"
+};
+var Permission = {
+  FarmerCluster: {
+    Default: "Framework.Cluster",
+    Create: "Framework.Cluster.Create",
+    Update: "Framework.Cluster.Update",
+    Delete: "Framework.Cluster.Delete",
+    AddNews: "Framework.Cluster.AddNews",
+    EditNews: "Framework.Cluster.EditNews",
+    DeleteNews: "Framework.Cluster.DeleteNews",
+    ViewNews: "Framework.Cluster.ViewNews",
+    ViewFarmers: "Framework.Cluster.ViewFarmers",
+    RemoveFarmer: "Framework.Cluster.RemoveFarmer",
+    AddFarmer: "Framework.Cluster.AddFarmer"
+  },
+  Resource: {
+    Default: "Framework.Resource",
+    Create: "Framework.Resource.Create",
+    Update: "Framework.Resource.Update",
+    Delete: "Framework.Resource.Delete"
+  },
+  File: {
+    Default: "GeoWiki.File",
+    Create: "GeoWiki.File.Create",
+    Delete: "GeoWiki.File.Delete",
+    Update: "GeoWiki.File.Update"
+  },
+  News: {
+    Default: "GeoWiki.News",
+    Create: "GeoWiki.News.Create",
+    Delete: "GeoWiki.News.Delete",
+    Update: "GeoWiki.News.Update"
+  },
+  Tenants: {
+    Default: "AbpTenantManagement.Tenants",
+    Create: "AbpTenantManagement.Tenants.Create",
+    Delete: "AbpTenantManagement.Tenants.Delete",
+    Update: "AbpTenantManagement.Tenants.Update",
+    ManageConnectionStrings: "AbpTenantManagement.Tenants.ManageConnectionStrings",
+    ManageFeatures: "AbpTenantManagement.Tenants.ManageFeatures"
+  },
+  Layer: {
+    Default: "GeoWiki.Layer",
+    Create: "GeoWiki.Layer.Create",
+    Delete: "GeoWiki.Layer.Delete",
+    Update: "GeoWiki.Layer.Update"
+  },
+  LayerCategory: {
+    Default: "GeoWiki.LayerCategory",
+    Create: "GeoWiki.LayerCategory.Create",
+    Delete: "GeoWiki.LayerCategory.Delete",
+    Update: "GeoWiki.LayerCategory.Update"
+  },
+  LayerInfo: {
+    Default: "GeoWiki.LayerInfo",
+    Create: "GeoWiki.LayerInfo.Create",
+    Delete: "GeoWiki.LayerInfo.Delete",
+    Update: "GeoWiki.LayerInfo.Update"
+  },
+  Settings: {
+    Default: "GeoWiki.Settings",
+    Create: "GeoWiki.Settings.Create",
+    Update: "GeoWiki.Settings.Update"
+  },
+  Dashboard: {
+    Default: "GeoWiki.Dashboard"
+  }
+};
+var USER_ROLE = /* @__PURE__ */ ((USER_ROLE2) => {
+  USER_ROLE2["ADMIN"] = "admin";
+  USER_ROLE2["FARMER_CLUSTER_ADMIN"] = "FarmerClusterAdmin";
+  return USER_ROLE2;
+})(USER_ROLE || {});
+var PermissionProvider = /* @__PURE__ */ ((PermissionProvider2) => {
+  PermissionProvider2["U"] = "U";
+  PermissionProvider2["R"] = "R";
+  PermissionProvider2["T"] = "T";
+  return PermissionProvider2;
+})(PermissionProvider || {});
+var Features = {
+  FarmerCluster: "Framework.FarmerCluster",
+  FarmerClusterNews: "Framework.FarmerCluster.News",
+  SettingManagementEnable: "SettingManagement.Enable",
+  GeoWikiLogin: "GeoWiki.Login",
+  GeoWikiSettings: "GeoWiki.Settings",
+  SettingManagementAllowTenantsToChangeEmailSettings: "SettingManagement.AllowTenantsToChangeEmailSettings",
+  Resources: "Framework.FarmerCluster.Resource"
+};
+var FarmingSystem = [
+  { value: "Conventional", label: "Conventional" },
+  { value: "Organic", label: "Organic" },
+  { value: "Certified", label: "Certified" },
+  { value: "Other", label: "Other" }
+];
+var MainAgriculturalAreas = [
+  { value: "NonPermanentCrops", label: "Non permanent crops" },
+  {
+    value: "PermanentCultureAndTrees",
+    label: "Permanent cultures and trees (fruit orchards, plantations, olive groves, vineyards, tree nurseries, etc.)"
+  },
+  { value: "TemporaryFallow", label: "Temporary fallow" },
+  {
+    value: "Grassland",
+    label: "Grassland (meadows, pasture, other grassland)"
+  },
+  { value: "Other", label: "Other" }
+];
+var MainCrops = [
+  { value: "Cereals", label: "Cereals" },
+  { value: "VegetablesAndMelons", label: "Vegetables and melons" },
+  { value: "FruitAndNuts", label: "Fruit and nuts" },
+  { value: "OilseedCrops", label: "Oilseed crops" },
+  { value: "RootsAndTubers", label: "Roots and tubers" },
+  { value: "BeverageCropsAndSpices", label: "Beverage crops and spices" },
+  { value: "LeguminousCrops", label: "Leguminous crops" },
+  { value: "SugarCrops", label: "Sugar crops" },
+  {
+    value: "OtherCropsIncludingGrasses",
+    label: "Other crops, including grasses"
+  }
+];
+var LiveStock = [
+  { value: "Cattle", label: "Cattle" },
+  { value: "SheepAndGoats", label: "Sheep and goats" },
+  { value: "Pigs", label: "Pigs" },
+  {
+    value: "HorsesMulesAndOtherEquines",
+    label: "Horses, mules and other equines"
+  },
+  { value: "CamelsAndCamelids", label: "Camels and camelids" },
+  { value: "Poultry", label: "Poultry" },
+  { value: "InsectsIncludingBees", label: "Insects, including bees" },
+  { value: "PigeonsAndOtherBirds", label: "Pigeons and other birds" },
+  { value: "OtherAnimals", label: "Other animals" },
+  { value: "NoLivestock", label: "No livestock" }
+];
+var OtherLandscapeElements = [
+  {
+    value: "WoodyElements",
+    label: "Woody elements (trees, tree lines, hedges, other woody strips)"
+  },
+  { value: "FlowerAreasAndStrips", label: "Flower areas and strips" },
+  { value: "Scrubland", label: "Scrubland" },
+  {
+    value: "GrassStripsReedOrSedgeBeds",
+    label: "Grassy strips, reed or sedge beds"
+  },
+  {
+    value: "WaterElement",
+    label: "Water elements (running fresh water, ponds, ditches)"
+  },
+  {
+    value: "StoneRockAndSand",
+    label: "Stone, rock, sands, bare soil or terrace elements"
+  },
+  { value: "Forest", label: "Forest" },
+  { value: "Wetland", label: "Wetland" },
+  { value: "OpenWaters", label: "Open waters" }
+];
+var HuntingManagement = [
+  { value: "SmallGame", label: "Small game" },
+  { value: "BigGame", label: "Big game" },
+  { value: "NoHunting", label: "No hunting" }
+];
+var ClusterFunding = [
+  { value: "LocalAndRegional", label: "Local / Regional" },
+  { value: "National", label: "National" },
+  { value: "DirectEU", label: "Direct EU" },
+  { value: "SelfFunded", label: "Self funded" },
+  { value: "Other", label: "Other" }
+];
+var ActivityStatus = [
+  { value: "Active", label: "Active" },
+  { value: "Dormant", label: "Dormant" },
+  { value: "Discontinued", label: "Discontinued" }
+];
+var routes = {
+  EditFarmerCluster: [
+    {
+      path: "/",
+      name: "Home"
+    },
+    {
+      path: "/admin/cluster",
+      name: "My Area"
+    },
+    {
+      path: "/admin/cluster",
+      name: "My Farmer Clusters"
+    },
+    {
+      path: "#",
+      name: "Edit Farmer Cluster"
+    }
+  ],
+  ViewFarmerClusterNews: [
+    {
+      path: "/",
+      name: "Home"
+    },
+    {
+      path: "/farmer-cluster",
+      name: "Farmer Clusters"
+    }
+  ]
+};
+var imageMaxDimension = {
+  width: 1920,
+  height: 1080
+};
+var imageMinDimension = {
+  width: 400,
+  height: 250
+};
+var ImageError = "Image size requires a minimum 400px width and 250px height and is limited to max 1920px width and 1080px height.";
+var ColorArray = [
+  "#423e4f",
+  "#0072bb",
+  "#009489",
+  "#a47218",
+  "#516c24",
+  "#EC7063",
+  "#5B2C6F",
+  "#F1C40F"
+];
+var ColorArrayCSSClass = [
+  "bg-zinc-600",
+  "bg-sky-600",
+  "bg-teal-600",
+  "bg-yellow-600",
+  "bg-primary",
+  "bg-rose-300",
+  "bg-purple-600",
+  "bg-orange-300"
+];
+var Responsive = {
+  desktop: {
+    breakpoint: { max: 3e3, min: 1024 },
+    items: 3,
+    slidesToSlide: 3
+    // optional, default to 1.
+  },
+  tablet: {
+    breakpoint: { max: 1024, min: 464 },
+    items: 2,
+    slidesToSlide: 2
+    // optional, default to 1.
+  },
+  mobile: {
+    breakpoint: { max: 464, min: 0 },
+    items: 1,
+    slidesToSlide: 1
+    // optional, default to 1.
+  }
+};
+var ResourcesMenu = [
+  {
+    id: "1",
+    name: "Resources",
+    url: "/resources",
+    newTab: false,
+    children: [
+      {
+        id: "2",
+        name: "Resource Finder",
+        url: "/resources",
+        newTab: false
+      },
+      {
+        id: "3",
+        name: "Collections",
+        url: "/resources/collections",
+        newTab: false
+      }
+    ]
+  }
+];
+var NewsDefaultImage = "3a084680-7984-e07d-d44e-d58f946604e3";
+var LookUps = {
+  ClusterCountries: "Get countries in clusters",
+  ClusterActivityStatus: "Get activity status in clusters",
+  ClusterFarmingSystem: "Get farming system in clusters",
+  ClusterMainAgricultureArea: "Get main agriculture areas in clusters",
+  ClusterMainCrops: "Get main crops in clusters"
+};
+var AdminMenus = [
+  {
+    name: "Home",
+    link: "/admin",
+    icon: HomeIcon
+  },
+  {
+    name: "Administration",
+    icon: WrenchIcon,
+    children: [
+      {
+        name: "Roles",
+        link: "/admin/users/roles"
+      },
+      {
+        name: "Users",
+        link: "/admin/users"
+      }
+    ],
+    roles: ["admin" /* ADMIN */]
+  },
+  {
+    name: "Tenant Management",
+    icon: UserIcon,
+    children: [
+      {
+        name: "Tenants",
+        link: "/admin/tenants"
+      }
+    ],
+    roles: ["admin" /* ADMIN */]
+  },
+  {
+    name: "Settings",
+    link: "/admin/settings",
+    icon: "SettingsIcon",
+    roles: ["admin" /* ADMIN */]
+  },
+  {
+    name: "Account",
+    link: "/profile",
+    icon: "AccountIcon",
+    roles: ["admin" /* ADMIN */, "FarmerClusterAdmin" /* FARMER_CLUSTER_ADMIN */]
+  },
+  {
+    name: "Farmer Clusters",
+    link: "/admin/cluster",
+    icon: "FarmerClustersIcon",
+    roles: ["admin" /* ADMIN */, "FarmerClusterAdmin" /* FARMER_CLUSTER_ADMIN */],
+    feature: [Features.FarmerCluster]
+  },
+  {
+    name: "Resources",
+    link: "/admin/resource",
+    icon: "ResourcesIcon",
+    roles: ["admin" /* ADMIN */],
+    feature: [Features.Resources]
+  }
+];
+var CLUSTER_ACTIVITY_STATUS = [
+  { value: "Active", label: "Active" },
+  { value: "Dormant", label: "Dormant" },
+  { value: "Discontinued", label: "Discontinued" }
+];
+
+// src/utils/analytics.ts
+var trackUmamiEvent = (eventName, eventData, session) => {
+  var _a, _b, _c;
+  console.log("trackUmamiEvent called:", eventName, eventData);
+  if (typeof window !== "undefined" && window.umami) {
+    const userInfo = session ? {
+      userId: (_a = session.user) == null ? void 0 : _a.email,
+      // Using email as userId since id might not be available
+      userEmail: (_b = session.user) == null ? void 0 : _b.email,
+      userName: (_c = session.user) == null ? void 0 : _c.name
+    } : {};
+    window.umami.track(eventName, __spreadValues(__spreadValues({}, eventData), userInfo));
+    console.log("Umami track called with:", eventName, __spreadValues(__spreadValues({}, eventData), userInfo));
+  } else {
+    console.log("Umami not available or window undefined");
+  }
+};
+var trackDownloadEvent = {
+  /**
+   * Track download attempt
+   */
+  attempt: (format, country, version, purpose, session) => {
+    trackUmamiEvent(
+      "download_attempt",
+      { format, country, version, purpose },
+      session
+    );
+  },
+  /**
+   * Track successful download
+   */
+  success: (filename, purpose, session) => {
+    trackUmamiEvent("download_success", { filename, purpose }, session);
+  },
+  /**
+   * Track download failure
+   */
+  failure: (error, purpose, session) => {
+    trackUmamiEvent("download_failure", { error, purpose }, session);
+  },
+  /**
+   * Track login attempt for download access
+   */
+  loginAttempt: (session) => {
+    trackUmamiEvent("download_login_attempt", {}, session);
+  }
+};
+var trackAuthEvent = {
+  /**
+   * Track login attempt
+   */
+  loginAttempt: (provider, session) => {
+    trackUmamiEvent("auth_login_attempt", { provider }, session);
+  },
+  /**
+   * Track successful login
+   */
+  loginSuccess: (provider, session) => {
+    trackUmamiEvent("auth_login_success", { provider }, session);
+  },
+  /**
+   * Track logout
+   */
+  logout: (session) => {
+    trackUmamiEvent("auth_logout", {}, session);
+  }
+};
+var trackUserEvent = {
+  /**
+   * Track page view
+   */
+  pageView: (page, session) => {
+    trackUmamiEvent("page_view", { page }, session);
+  },
+  /**
+   * Track button click
+   */
+  buttonClick: (buttonName, context, session) => {
+    trackUmamiEvent("button_click", { buttonName, context }, session);
+  },
+  /**
+   * Track form submission
+   */
+  formSubmit: (formName, session) => {
+    trackUmamiEvent("form_submit", { formName }, session);
+  },
+  /**
+   * Track map control button click with specific context
+   */
+  mapControlClick: (controlName, action, session) => {
+    trackUmamiEvent("map_control_click", { controlName, action }, session);
+  }
+};
+var trackMapEvent = {
+  /**
+   * Track layer toggle
+   */
+  layerToggle: (layerName, action, session) => {
+    console.log("Tracking layer toggle:", layerName, action);
+    trackUmamiEvent("map_layer_toggle", { layerName, action }, session);
+  },
+  /**
+   * Track base layer change
+   */
+  baseLayerChange: (baseLayerName, session) => {
+    trackUmamiEvent("map_base_layer_change", { baseLayerName }, session);
+  },
+  /**
+   * Track layer opacity change
+   */
+  layerOpacityChange: (layerName, opacity, session) => {
+    trackUmamiEvent(
+      "map_layer_opacity_change",
+      { layerName, opacity },
+      session
+    );
+  },
+  /**
+   * Track layer reorder
+   */
+  layerReorder: (layerName, newPosition, session) => {
+    trackUmamiEvent("map_layer_reorder", { layerName, newPosition }, session);
+  },
+  /**
+   * Track layer info view
+   */
+  layerInfoView: (layerName, session) => {
+    trackUmamiEvent("map_layer_info_view", { layerName }, session);
+  },
+  /**
+   * Track measurement tool usage
+   */
+  measurementTool: (action, session) => {
+    trackUmamiEvent("map_measurement_tool", { action }, session);
+  },
+  /**
+   * Track zoom control usage
+   */
+  zoomControl: (action, session) => {
+    trackUmamiEvent("map_zoom_control", { action }, session);
+  },
+  /**
+   * Track legend interaction
+   */
+  legendInteraction: (action, session) => {
+    trackUmamiEvent("map_legend_interaction", { action }, session);
+  }
+};
+export {
+  ActivityStatus,
+  AdminMenus,
+  AnnotationRequired,
+  CLUSTER_ACTIVITY_STATUS,
+  ClusterFunding,
+  ColorArray,
+  ColorArrayCSSClass,
+  Config,
+  DOTS,
+  FarmingSystem,
+  Features,
+  HostService,
+  HostType,
+  HuntingManagement,
+  ImageError,
+  IsTokenExpired,
+  LiveStock,
+  LookUps,
+  MainAgriculturalAreas,
+  MainCrops,
+  NewsDefaultImage,
+  OtherLandscapeElements,
+  Permission,
+  PermissionProvider,
+  QueryConstants,
+  QueryNames,
+  QuestionnaireType,
+  ResourcesMenu,
+  Responsive,
+  StyleType,
+  TaskEventType,
+  TaskState,
+  TaskStatus2 as TaskStatus,
+  TaskStatusColor,
+  USER_ROLE,
+  ViewStatus,
+  classNames,
+  configStore,
+  delayedSlideInUp,
+  downloadData,
+  downloadJSON,
+  easing,
+  findHostInfo,
+  formatUnixDate,
+  getButtonAppearance,
+  getCmsUrlForHost,
+  getContentWithSlug,
+  getContentWithTypeAndDisplayName,
+  getContentsWithType,
+  getDefaultSettings,
+  getGeoWikiSettings,
+  getHostData,
+  getHostFromRequest,
+  getHtmlElementFromReactNode,
+  getMediaUrl,
+  getMenus,
+  getPageContent,
+  getPageProps,
+  getTenantIdForHost,
+  i18n,
+  imageMaxDimension,
+  imageMinDimension,
+  itemVariants,
+  keyStr,
+  listVariants,
+  rgbDataURL,
+  routes,
+  scrollToFirstErrorElement,
+  settingsStore,
+  shimmer,
+  showIntroTour,
+  slideInLeft,
+  slideInRight,
+  slideInUp,
+  spring,
+  toBase64,
+  tokenData,
+  trackAuthEvent,
+  trackDownloadEvent,
+  trackMapEvent,
+  trackUmamiEvent,
+  trackUserEvent,
+  triplet,
+  useAllNewsFromAllClusters,
+  useApiImage,
+  useApiUrl,
+  useAppConfig,
+  useAssignProjectToUser,
+  useAssignableRoles,
+  useAudience,
+  useBasfStore,
+  useBreadCrumbStore,
+  useCluster,
+  useClusterAllNews,
+  useClusterDescription,
+  useClusterDetails,
+  useClusterFilterSettings,
+  useClusterGetJoinRequests,
+  useClusterGetNews,
+  useClusterGetNewsNextPreviousStatus,
+  useClusterImages,
+  useClusterImagesAndVideos,
+  useClusterLinks,
+  useClusterMapInfo,
+  useClusterNews,
+  useClusterNewsWithId,
+  useClusterOverview,
+  useClusters,
+  useCmsContentWithType,
+  useCmsImage,
+  useCmsUrl,
+  useConfigSettings,
+  useContractStatisticsByUser,
+  useCountries,
+  useCreateHost,
+  useCurrentUser,
+  useDefaultSettings,
+  useDeleteHost,
+  useDimensions,
+  useEmailing,
+  useEvolandBands,
+  useEvolandLabels,
+  useEvolandWmsLayers,
+  useFeature,
+  useFeatures,
+  useFileUpload,
+  useFileUrl,
+  useFilterClusters,
+  useGeoWikiSettings,
+  useGetUserProject,
+  useGrantedPolicies,
+  useGroupsInProject,
+  useHost,
+  useHosts,
+  useImageUrl,
+  useIntroTourSettings,
+  useIsAdmin,
+  useIsAuthenticated,
+  useIsInRole,
+  useLanguages,
+  useLatestTaskOnLocation,
+  useLayerInfo,
+  useLayerStore,
+  useLocation,
+  useLocationBulkUpload,
+  useLocationsForProject,
+  useLockBodyScroll,
+  useLookUp,
+  useMapMenuItems,
+  useNews,
+  useNewsFromAllClusters,
+  usePagination,
+  usePanelStore,
+  usePermission,
+  usePermissions,
+  useProfile,
+  useProjectDetails,
+  useProjectResultSet,
+  useProjectStatisticsByUser,
+  useProjectUsers,
+  useProjects,
+  useProjectsPointsDownload,
+  usePublicationSettings,
+  useQuestionnaire,
+  useRandomTasksPerLocation,
+  useRenderInfo,
+  useResource,
+  useResourceFilter,
+  useResourceType,
+  useReviewTaskBulkUpload,
+  useRoles,
+  useTaskAnnotation,
+  useTaskAnswers,
+  useTaskBulkUpload,
+  useTaskComments,
+  useTaskDelete,
+  useTaskMultipleAnnotations,
+  useTaskSavedAnnotations,
+  useTaskStatusList,
+  useTasksPerLocation,
+  useTenants,
+  useTopic,
+  useUpdateActiveGroupInProject,
+  useUpdateHost,
+  useUpdateUserDetail,
+  useUserProfileGet,
+  useUserRoles,
+  useUsers
+};