@geowiki/core 0.15.0-dev.1

package/dist/index.js

@@ -0,0 +1,3447 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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/index.tsx
+var src_exports = {};
+__export(src_exports, {
+  ActivityStatus: () => ActivityStatus,
+  AdminMenus: () => AdminMenus,
+  AnnotationRequired: () => AnnotationRequired,
+  CLUSTER_ACTIVITY_STATUS: () => CLUSTER_ACTIVITY_STATUS,
+  ClusterFunding: () => ClusterFunding,
+  ColorArray: () => ColorArray,
+  ColorArrayCSSClass: () => ColorArrayCSSClass,
+  Config: () => Config,
+  DOTS: () => DOTS,
+  FarmingSystem: () => FarmingSystem,
+  Features: () => Features,
+  HostService: () => HostService,
+  HostType: () => HostType,
+  HuntingManagement: () => HuntingManagement,
+  ImageError: () => ImageError,
+  IsTokenExpired: () => IsTokenExpired,
+  LiveStock: () => LiveStock,
+  LookUps: () => LookUps,
+  MainAgriculturalAreas: () => MainAgriculturalAreas,
+  MainCrops: () => MainCrops,
+  NewsDefaultImage: () => NewsDefaultImage,
+  OtherLandscapeElements: () => OtherLandscapeElements,
+  Permission: () => Permission,
+  PermissionProvider: () => PermissionProvider,
+  QueryConstants: () => QueryConstants,
+  QueryNames: () => QueryNames,
+  QuestionnaireType: () => QuestionnaireType,
+  ResourcesMenu: () => ResourcesMenu,
+  Responsive: () => Responsive,
+  StyleType: () => StyleType,
+  TaskEventType: () => TaskEventType,
+  TaskState: () => TaskState,
+  TaskStatus: () => TaskStatus2,
+  TaskStatusColor: () => TaskStatusColor,
+  USER_ROLE: () => USER_ROLE,
+  ViewStatus: () => ViewStatus,
+  classNames: () => classNames,
+  configStore: () => configStore,
+  delayedSlideInUp: () => delayedSlideInUp,
+  downloadData: () => downloadData,
+  downloadJSON: () => downloadJSON,
+  easing: () => easing,
+  findHostInfo: () => findHostInfo,
+  formatUnixDate: () => formatUnixDate,
+  getButtonAppearance: () => getButtonAppearance,
+  getCmsUrlForHost: () => getCmsUrlForHost,
+  getContentWithSlug: () => getContentWithSlug,
+  getContentWithTypeAndDisplayName: () => getContentWithTypeAndDisplayName,
+  getContentsWithType: () => getContentsWithType,
+  getDefaultSettings: () => getDefaultSettings,
+  getGeoWikiSettings: () => getGeoWikiSettings,
+  getHostData: () => getHostData,
+  getHostFromRequest: () => getHostFromRequest,
+  getHtmlElementFromReactNode: () => getHtmlElementFromReactNode,
+  getMediaUrl: () => getMediaUrl,
+  getMenus: () => getMenus,
+  getPageContent: () => getPageContent,
+  getPageProps: () => getPageProps,
+  getTenantIdForHost: () => getTenantIdForHost,
+  i18n: () => i18n,
+  imageMaxDimension: () => imageMaxDimension,
+  imageMinDimension: () => imageMinDimension,
+  itemVariants: () => itemVariants,
+  keyStr: () => keyStr,
+  listVariants: () => listVariants,
+  rgbDataURL: () => rgbDataURL,
+  routes: () => routes,
+  scrollToFirstErrorElement: () => scrollToFirstErrorElement,
+  settingsStore: () => settingsStore,
+  shimmer: () => shimmer,
+  showIntroTour: () => showIntroTour,
+  slideInLeft: () => slideInLeft,
+  slideInRight: () => slideInRight,
+  slideInUp: () => slideInUp,
+  spring: () => spring,
+  toBase64: () => toBase64,
+  tokenData: () => tokenData,
+  trackAuthEvent: () => trackAuthEvent,
+  trackDownloadEvent: () => trackDownloadEvent,
+  trackMapEvent: () => trackMapEvent,
+  trackUmamiEvent: () => trackUmamiEvent,
+  trackUserEvent: () => trackUserEvent,
+  triplet: () => triplet,
+  useAllNewsFromAllClusters: () => useAllNewsFromAllClusters,
+  useApiImage: () => useApiImage,
+  useApiUrl: () => useApiUrl,
+  useAppConfig: () => useAppConfig,
+  useAssignProjectToUser: () => useAssignProjectToUser,
+  useAssignableRoles: () => useAssignableRoles,
+  useAudience: () => useAudience,
+  useBasfStore: () => useBasfStore,
+  useBreadCrumbStore: () => useBreadCrumbStore,
+  useCluster: () => useCluster,
+  useClusterAllNews: () => useClusterAllNews,
+  useClusterDescription: () => useClusterDescription,
+  useClusterDetails: () => useClusterDetails,
+  useClusterFilterSettings: () => useClusterFilterSettings,
+  useClusterGetJoinRequests: () => useClusterGetJoinRequests,
+  useClusterGetNews: () => useClusterGetNews,
+  useClusterGetNewsNextPreviousStatus: () => useClusterGetNewsNextPreviousStatus,
+  useClusterImages: () => useClusterImages,
+  useClusterImagesAndVideos: () => useClusterImagesAndVideos,
+  useClusterLinks: () => useClusterLinks,
+  useClusterMapInfo: () => useClusterMapInfo,
+  useClusterNews: () => useClusterNews,
+  useClusterNewsWithId: () => useClusterNewsWithId,
+  useClusterOverview: () => useClusterOverview,
+  useClusters: () => useClusters,
+  useCmsContentWithType: () => useCmsContentWithType,
+  useCmsImage: () => useCmsImage,
+  useCmsUrl: () => useCmsUrl,
+  useConfigSettings: () => useConfigSettings,
+  useContractStatisticsByUser: () => useContractStatisticsByUser,
+  useCountries: () => useCountries,
+  useCreateHost: () => useCreateHost,
+  useCurrentUser: () => useCurrentUser,
+  useDefaultSettings: () => useDefaultSettings,
+  useDeleteHost: () => useDeleteHost,
+  useDimensions: () => useDimensions,
+  useEmailing: () => useEmailing,
+  useEvolandBands: () => useEvolandBands,
+  useEvolandLabels: () => useEvolandLabels,
+  useEvolandWmsLayers: () => useEvolandWmsLayers,
+  useFeature: () => useFeature,
+  useFeatures: () => useFeatures,
+  useFileUpload: () => useFileUpload,
+  useFileUrl: () => useFileUrl,
+  useFilterClusters: () => useFilterClusters,
+  useGeoWikiSettings: () => useGeoWikiSettings,
+  useGetUserProject: () => useGetUserProject,
+  useGrantedPolicies: () => useGrantedPolicies,
+  useGroupsInProject: () => useGroupsInProject,
+  useHost: () => useHost,
+  useHosts: () => useHosts,
+  useImageUrl: () => useImageUrl,
+  useIntroTourSettings: () => useIntroTourSettings,
+  useIsAdmin: () => useIsAdmin,
+  useIsAuthenticated: () => useIsAuthenticated,
+  useIsInRole: () => useIsInRole,
+  useLanguages: () => useLanguages,
+  useLatestTaskOnLocation: () => useLatestTaskOnLocation,
+  useLayerInfo: () => useLayerInfo,
+  useLayerStore: () => useLayerStore,
+  useLocation: () => useLocation,
+  useLocationBulkUpload: () => useLocationBulkUpload,
+  useLocationsForProject: () => useLocationsForProject,
+  useLockBodyScroll: () => useLockBodyScroll,
+  useLookUp: () => useLookUp,
+  useMapMenuItems: () => useMapMenuItems,
+  useNews: () => useNews,
+  useNewsFromAllClusters: () => useNewsFromAllClusters,
+  usePagination: () => usePagination,
+  usePanelStore: () => usePanelStore,
+  usePermission: () => usePermission,
+  usePermissions: () => usePermissions,
+  useProfile: () => useProfile,
+  useProjectDetails: () => useProjectDetails,
+  useProjectResultSet: () => useProjectResultSet,
+  useProjectStatisticsByUser: () => useProjectStatisticsByUser,
+  useProjectUsers: () => useProjectUsers,
+  useProjects: () => useProjects,
+  useProjectsPointsDownload: () => useProjectsPointsDownload,
+  usePublicationSettings: () => usePublicationSettings,
+  useQuestionnaire: () => useQuestionnaire,
+  useRandomTasksPerLocation: () => useRandomTasksPerLocation,
+  useRenderInfo: () => useRenderInfo,
+  useResource: () => useResource,
+  useResourceFilter: () => useResourceFilter,
+  useResourceType: () => useResourceType,
+  useReviewTaskBulkUpload: () => useReviewTaskBulkUpload,
+  useRoles: () => useRoles,
+  useTaskAnnotation: () => useTaskAnnotation,
+  useTaskAnswers: () => useTaskAnswers,
+  useTaskBulkUpload: () => useTaskBulkUpload,
+  useTaskComments: () => useTaskComments,
+  useTaskDelete: () => useTaskDelete,
+  useTaskMultipleAnnotations: () => useTaskMultipleAnnotations,
+  useTaskSavedAnnotations: () => useTaskSavedAnnotations,
+  useTaskStatusList: () => useTaskStatusList,
+  useTasksPerLocation: () => useTasksPerLocation,
+  useTenants: () => useTenants,
+  useTopic: () => useTopic,
+  useUpdateActiveGroupInProject: () => useUpdateActiveGroupInProject,
+  useUpdateHost: () => useUpdateHost,
+  useUpdateUserDetail: () => useUpdateUserDetail,
+  useUserProfileGet: () => useUserProfileGet,
+  useUserRoles: () => useUserRoles,
+  useUsers: () => useUsers
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+var import_react_query = require("@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 (0, import_react_query.useQuery)({
+    queryKey: [QueryNames.GetAvailableBands],
+    queryFn: () => {
+    }
+  });
+};
+
+// src/hooks/useEvolandWmsLayers.ts
+var import_react_query2 = require("@tanstack/react-query");
+var import_evoland_api_proxy = require("@geowiki/evoland-api-proxy");
+var useEvolandWmsLayers = () => {
+  return (0, import_react_query2.useQuery)({
+    queryKey: [QueryNames.GetAvailableWmsLayers],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_evoland_api_proxy.ProjectService.getAvailableLayersAvailablelayersGet();
+      return data;
+    })
+  });
+};
+
+// src/stores/config.ts
+var import_vanilla = require("zustand/vanilla");
+var configStore = (0, import_vanilla.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
+var import_react_query3 = require("@tanstack/react-query");
+var import_api_proxy = require("@geowiki/api-proxy");
+var useAppConfig = () => {
+  return (0, import_react_query3.useQuery)({
+    queryKey: [QueryConstants.GetAppConfig],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy.AbpApplicationConfigurationService.abpApplicationConfigurationGet();
+      return data;
+    }),
+    staleTime: 60 * 60 * 1e3
+    // 1 hour
+  });
+};
+
+// src/hooks/useAudience.ts
+var import_api_proxy2 = require("@geowiki/api-proxy");
+var import_react_query4 = require("@tanstack/react-query");
+var useAudience = () => {
+  return (0, import_react_query4.useQuery)({
+    queryKey: [QueryNames.GetAudience],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy2.ResourceService.resourceGetAvailableAudience();
+      return data;
+    }),
+    staleTime: 1e3 * 60 * 60 * 24,
+    gcTime: 1e3 * 60 * 60 * 24,
+    placeholderData: import_react_query4.keepPreviousData
+  });
+};
+
+// src/hooks/useCluster.ts
+var import_api_proxy3 = require("@geowiki/api-proxy");
+var import_react_query5 = require("@tanstack/react-query");
+var useCluster = (id) => {
+  return (0, import_react_query5.useQuery)({
+    queryKey: [QueryNames.Cluster, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy3.ClusterService.clusterGet(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterFilterSettings.ts
+var import_cms_proxy = require("@geowiki/cms-proxy");
+var import_react_query6 = require("@tanstack/react-query");
+var useClusterFilterSettings = () => {
+  return (0, import_react_query6.useQuery)({
+    queryKey: [QueryNames.GetClusterFilterSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield import_cms_proxy.SettingsService.settingsGetSiteSettings("ClusterFilter");
+      return req;
+    })
+  });
+};
+var useConfigSettings = () => {
+  return (0, import_react_query6.useQuery)({
+    queryKey: [QueryNames.GetConfig],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield import_cms_proxy.SettingsService.settingsGetSiteSettings("Config");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterMapInfo.ts
+var import_api_proxy4 = require("@geowiki/api-proxy");
+var import_react_query7 = require("@tanstack/react-query");
+var useClusterMapInfo = () => {
+  return (0, import_react_query7.useQuery)({
+    queryKey: [QueryNames.GetClusterForMap],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy4.ClusterService.clusterGetMapInfo();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusters.ts
+var import_api_proxy5 = require("@geowiki/api-proxy");
+var import_react_query8 = require("@tanstack/react-query");
+var useClusters = (fetchAll = false, sort = "", skip = 0, take = 100) => {
+  return (0, import_react_query8.useQuery)({
+    queryKey: [QueryNames.Clusters, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetchAll) {
+        const data = yield import_api_proxy5.ClusterService.clusterGetAllClusters(
+          sort,
+          skip,
+          take
+        );
+        return data;
+      } else {
+        const data = yield import_api_proxy5.ClusterService.clusterGetList(sort, skip, take);
+        return data;
+      }
+    }),
+    placeholderData: import_react_query8.keepPreviousData
+  });
+};
+var useAllNewsFromAllClusters = (sort = "", skip = 0, take = 100) => {
+  return (0, import_react_query8.useQuery)({
+    queryKey: [QueryNames.GetFarmerClusterNews, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy5.ClusterService.clusterGetAllNewsFromAllClusters(
+        sort,
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useHosts.ts
+var import_react_query9 = require("@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 (0, import_react_query9.useQuery)({
+    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
+var import_react_query10 = require("@tanstack/react-query");
+var import_api_proxy6 = require("@geowiki/api-proxy");
+var useCountries = (fetchAll = false) => {
+  return (0, import_react_query10.useQuery)({
+    queryKey: [QueryNames.GetCountries, fetchAll],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy6.ClusterService.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
+var import_react = require("react");
+var useDimensions = (ref) => {
+  const dimensions = (0, import_react.useRef)({ width: 0, height: 0 });
+  (0, import_react.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
+var import_api_proxy7 = require("@geowiki/api-proxy");
+var import_react_query11 = require("@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 (0, import_react_query11.useQuery)({
+    queryKey: [QueryNames.FileUpload, formData],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy7.FileService.fileUpload(formData);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useFilterClusters.ts
+var import_api_proxy8 = require("@geowiki/api-proxy");
+var import_react_query12 = require("@tanstack/react-query");
+var useFilterClusters = (filter) => {
+  return (0, import_react_query12.useQuery)({
+    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 import_api_proxy8.ClusterService.clusterFilter(filter);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useGeoWikiSettings.ts
+var import_cms_proxy2 = require("@geowiki/cms-proxy");
+var import_react_query13 = require("@tanstack/react-query");
+var useGeoWikiSettings = () => {
+  return (0, import_react_query13.useQuery)({
+    queryKey: [QueryNames.GetAppSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield import_cms_proxy2.SettingsService.settingsGetSiteSettings("GeoWiki");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useImageUrl.ts
+var useImageUrl = () => {
+  var cmsUrl = useCmsUrl();
+  return `${cmsUrl}/media/`;
+};
+
+// src/hooks/useIntroTourSettings.ts
+var import_cms_proxy3 = require("@geowiki/cms-proxy");
+var import_react_query14 = require("@tanstack/react-query");
+var useIntroTourSettings = () => {
+  return (0, import_react_query14.useQuery)({
+    queryKey: [QueryNames.GetIntroTour],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield import_cms_proxy3.SettingsService.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
+var import_api_proxy9 = require("@geowiki/api-proxy");
+var import_react_query15 = require("@tanstack/react-query");
+var useLanguages = () => {
+  return (0, import_react_query15.useQuery)({
+    queryKey: [QueryNames.GetLanguages],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy9.ResourceService.resourceGetAvailableLanguages();
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: import_react_query15.keepPreviousData
+  });
+};
+
+// src/hooks/useLayerInfo.ts
+var import_react_query16 = require("@tanstack/react-query");
+var useLayerInfo = (url, layerName) => {
+  return (0, import_react_query16.useQuery)({
+    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
+var import_react2 = require("react");
+var import_evoland_api_proxy2 = require("@geowiki/evoland-api-proxy");
+var import_react_query17 = require("@tanstack/react-query");
+function useLocation() {
+  const [location, setLocation] = (0, import_react2.useState)();
+  (0, import_react2.useEffect)(() => {
+    navigator.geolocation.getCurrentPosition(function(position) {
+      setLocation(position.coords);
+    });
+  }, []);
+  return location;
+}
+var useLocationsForProject = (locationreq) => {
+  return (0, import_react_query17.useQuery)({
+    queryKey: [QueryConstants.GetLocations, locationreq],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy2.ProjectService.searchLocationsLocationsPost(locationreq);
+    })
+  });
+};
+var useLocationBulkUpload = (uploadLocations, file, project_id, group_id) => {
+  return (0, import_react_query17.useQuery)({
+    queryKey: [QueryConstants.UploadLocations, uploadLocations, file, group_id],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        const res = yield import_evoland_api_proxy2.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 (0, import_react_query17.useQuery)({
+    queryKey: [QueryConstants.UploadTasks, uploadTasks, file],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        return import_evoland_api_proxy2.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 (0, import_react_query17.useQuery)({
+    queryKey: [QueryConstants.UploadReviewTasks, uploadReviewTasks, file],
+    queryFn: () => __async(void 0, null, function* () {
+      try {
+        return import_evoland_api_proxy2.LocationService.bulkUploadReviewTasksUploadreviewtasksPost({ file, project_id });
+      } catch (error) {
+        return { data: error.body, isLoading: false, error: true };
+      }
+    }),
+    enabled: !!uploadReviewTasks && !!file
+  });
+};
+
+// src/hooks/useLockBodyScroll.ts
+var import_react3 = require("react");
+function useLockBodyScroll() {
+  (0, import_react3.useEffect)(() => {
+    const originalStyle = window.getComputedStyle(document.body).overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = originalStyle;
+    };
+  }, []);
+}
+
+// src/hooks/useMapSettings.ts
+var import_cms_proxy4 = require("@geowiki/cms-proxy");
+var import_react_query18 = require("@tanstack/react-query");
+
+// src/hooks/useNews.ts
+var import_react_query19 = require("@tanstack/react-query");
+var import_api_proxy10 = require("@geowiki/api-proxy");
+var useNews = (lang = "all", skip = 0, take = 100) => {
+  return (0, import_react_query19.useQuery)({
+    queryKey: [QueryNames.GetNews, lang, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (lang == "all") {
+        const res2 = yield import_api_proxy10.NewsService.newsGetExternalNews("", skip, take);
+        return res2.items;
+      }
+      const res = yield import_api_proxy10.NewsService.newsGetExternalNewsByLanguage(
+        "",
+        skip,
+        take,
+        lang
+      );
+      return res.items;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    placeholderData: import_react_query19.keepPreviousData,
+    staleTime: 1e3 * 60 * 60 * 24
+  });
+};
+
+// src/hooks/usePagination.ts
+var import_react4 = require("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 = (0, import_react4.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
+var import_cms_proxy5 = require("@geowiki/cms-proxy");
+var import_react_query20 = require("@tanstack/react-query");
+var usePublicationSettings = () => {
+  return (0, import_react_query20.useQuery)({
+    queryKey: [QueryNames.GetPublicationSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      var req = yield import_cms_proxy5.SettingsService.settingsGetSiteSettings("Publication");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useResource.ts
+var import_api_proxy11 = require("@geowiki/api-proxy");
+var import_react_query21 = require("@tanstack/react-query");
+var useResource = (search = "", sort = "", skip = 0, take = 100) => {
+  return (0, import_react_query21.useQuery)({
+    queryKey: [QueryNames.GetResource, search, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      if (search !== "") {
+        const data2 = yield import_api_proxy11.ResourceService.resourceSearch(search);
+        return data2;
+      }
+      const data = yield import_api_proxy11.ResourceService.resourceGetAll(sort, skip, take);
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: import_react_query21.keepPreviousData
+  });
+};
+
+// src/hooks/useResourceFilter.ts
+var import_api_proxy12 = require("@geowiki/api-proxy");
+var import_react_query22 = require("@tanstack/react-query");
+var useResourceFilter = (filter) => {
+  return (0, import_react_query22.useQuery)({
+    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 import_api_proxy12.ResourceService.resourceFilter(filter);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useResourceType.ts
+var import_api_proxy13 = require("@geowiki/api-proxy");
+var import_react_query23 = require("@tanstack/react-query");
+var useResourceType = () => {
+  return (0, import_react_query23.useQuery)({
+    queryKey: [QueryNames.GetResourceType],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield import_api_proxy13.ResourceService.resourceGetAvailableResourceType();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useTopic.ts
+var import_api_proxy14 = require("@geowiki/api-proxy");
+var import_react_query24 = require("@tanstack/react-query");
+var useTopic = () => {
+  return (0, import_react_query24.useQuery)({
+    queryKey: [QueryNames.GetTopic],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield import_api_proxy14.ResourceService.resourceGetAvailableTopic();
+      return data;
+    }),
+    gcTime: 1e3 * 60 * 60 * 24,
+    staleTime: 1e3 * 60 * 60 * 24,
+    placeholderData: import_react_query24.keepPreviousData
+  });
+};
+
+// src/hooks/useUserProfile.ts
+var import_react_query25 = require("@tanstack/react-query");
+var import_api_proxy15 = require("@geowiki/api-proxy");
+var useUserProfileGet = () => {
+  return (0, import_react_query25.useQuery)({
+    queryKey: [QueryNames.GetUserProfile],
+    queryFn: () => __async(void 0, null, function* () {
+      var data = yield import_api_proxy15.ProfileService.profileGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useUsers.ts
+var import_react_query26 = require("@tanstack/react-query");
+var import_api_proxy16 = require("@geowiki/api-proxy");
+var useUsers = (pageIndex, pageSize, filter, sorting) => {
+  return (0, import_react_query26.useQuery)({
+    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 import_api_proxy16.UserService.userGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useRenderInfo.ts
+var import_react5 = __toESM(require("react"));
+function useRenderInfo(name = "Unknown") {
+  const count = import_react5.default.useRef(0);
+  const lastRender = import_react5.default.useRef();
+  const now = Date.now();
+  count.current++;
+  import_react5.default.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
+var import_cms_proxy6 = require("@geowiki/cms-proxy");
+var import_react_query27 = require("@tanstack/react-query");
+var useDefaultSettings = () => {
+  return (0, import_react_query27.useQuery)({
+    queryKey: [QueryNames.DefaultSettings],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield import_cms_proxy6.SettingsService.settingsGetDefaultSiteSettings();
+      return req;
+    })
+  });
+};
+
+// src/hooks/useCurrentUser.ts
+var useCurrentUser = () => {
+  const { data } = useAppConfig();
+  return data == null ? void 0 : data.currentUser;
+};
+
+// src/hooks/useEmailing.ts
+var import_api_proxy17 = require("@geowiki/api-proxy");
+var import_react_query28 = require("@tanstack/react-query");
+var useEmailing = () => {
+  return (0, import_react_query28.useQuery)({
+    queryKey: [QueryConstants.GetEmailing],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy17.EmailSettingsService.emailSettingsGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useGrantedPolicies.ts
+var import_react6 = require("react");
+var useGrantedPolicies = () => {
+  var _a;
+  const { data } = useAppConfig();
+  const can = (0, import_react6.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
+var import_api_proxy18 = require("@geowiki/api-proxy");
+var import_react_query29 = require("@tanstack/react-query");
+var useFeatures = (providerName, providerKey) => {
+  return (0, import_react_query29.useQuery)({
+    queryKey: [QueryConstants.GetFeatures, providerName, providerKey],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy18.FeaturesService.featuresGet(providerName, providerKey);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useAssignableRoles.ts
+var import_react_query30 = require("@tanstack/react-query");
+var import_api_proxy19 = require("@geowiki/api-proxy");
+var useAssignableRoles = () => {
+  return (0, import_react_query30.useQuery)({
+    queryKey: [QueryConstants.GetAssignableRoles],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy19.UserService.userGetAssignableRoles();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useUserRoles.ts
+var import_api_proxy20 = require("@geowiki/api-proxy");
+var import_react_query31 = require("@tanstack/react-query");
+var useUserRoles = ({ userId }) => {
+  return (0, import_react_query31.useQuery)({
+    queryKey: [QueryConstants.GetUserRoles, userId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy20.UserService.userGetRoles(userId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/usePermissions.ts
+var import_api_proxy21 = require("@geowiki/api-proxy");
+var import_react_query32 = require("@tanstack/react-query");
+var usePermissions = (providerName, providerKey) => {
+  return (0, import_react_query32.useQuery)({
+    queryKey: [QueryConstants.GetPermissions, providerName, providerKey],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy21.PermissionsService.permissionsGet(
+        providerName,
+        providerKey
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useRoles.ts
+var import_react_query33 = require("@tanstack/react-query");
+var import_api_proxy22 = require("@geowiki/api-proxy");
+var useRoles = (pageIndex, pageSize, filter, sorting) => {
+  return (0, import_react_query33.useQuery)({
+    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 import_api_proxy22.RoleService.roleGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useProfile.ts
+var import_api_proxy23 = require("@geowiki/api-proxy");
+var import_react_query34 = require("@tanstack/react-query");
+var useProfile = () => {
+  return (0, import_react_query34.useQuery)({
+    queryKey: [QueryConstants.GetProfile],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy23.ProfileService.profileGet();
+      return data;
+    })
+  });
+};
+
+// src/hooks/useTenants.ts
+var import_react_query35 = require("@tanstack/react-query");
+var import_api_proxy24 = require("@geowiki/api-proxy");
+var useTenants = (pageIndex, pageSize, filter, sorting) => {
+  return (0, import_react_query35.useQuery)({
+    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 import_api_proxy24.TenantService.tenantGetList(
+        filter ? filter : void 0,
+        sorting ? sorting : void 0,
+        skip,
+        pageSize
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useEvolandLabels.ts
+var import_react_query36 = require("@tanstack/react-query");
+var import_evoland_api_proxy3 = require("@geowiki/evoland-api-proxy");
+var useEvolandLabels = (projectId) => {
+  return (0, import_react_query36.useQuery)({
+    queryKey: [QueryNames.GetEvolandLabels, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_evoland_api_proxy3.ProjectService.getLabelsLabelsProjectIdProjectIdGet(projectId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useLookUp.ts
+var import_react_query37 = require("@tanstack/react-query");
+var import_api_proxy25 = require("@geowiki/api-proxy");
+var useLookUp = (ServiceName, params, LookUpsClusterCountries, LookUpsClusterActivityStatus, LookUpsClusterFarmingSystem, LookUpsClusterMainAgricultureArea, LookUpsClusterMainCrops) => {
+  let result;
+  return (0, import_react_query37.useQuery)({
+    queryKey: [QueryNames.GetLookUp, ServiceName, params],
+    queryFn: () => __async(void 0, null, function* () {
+      switch (ServiceName) {
+        case LookUpsClusterCountries: {
+          result = yield import_api_proxy25.ClusterService.clusterGetCountries(params);
+          break;
+        }
+        case LookUpsClusterActivityStatus: {
+          result = yield import_api_proxy25.ClusterService.clusterGetActivityStatus(params);
+          break;
+        }
+        case LookUpsClusterFarmingSystem: {
+          result = yield import_api_proxy25.ClusterService.clusterGetFarmingSystems(params);
+          break;
+        }
+        case LookUpsClusterMainAgricultureArea: {
+          result = yield import_api_proxy25.ClusterService.clusterGetMainAgriculturalAreas(params);
+          break;
+        }
+        case LookUpsClusterMainCrops: {
+          result = yield import_api_proxy25.ClusterService.clusterGetMainCrops(params);
+          break;
+        }
+      }
+      return result;
+    })
+  });
+};
+
+// src/hooks/useProjects.ts
+var import_react_query38 = require("@tanstack/react-query");
+var import_evoland_api_proxy4 = require("@geowiki/evoland-api-proxy");
+var useProjects = (fetch2, start = 0, amount = 9) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetProjects, fetch2, start, amount],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetch2)
+        return import_evoland_api_proxy4.ProjectService.listProjectsListprojectsStartidxStartidxAmountAmountGet(
+          start,
+          amount
+        );
+    })
+  });
+};
+var useProjectDetails = (projectId, update) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetProjectDetails, projectId, update],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.projectInfoProjectinfoProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTasksPerLocation = (data) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTasksPerLocation, data],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.getTasksTasksGet(
+        data.locationProjectId,
+        data.taskForReview,
+        null,
+        data.orderBy,
+        data.search,
+        import_evoland_api_proxy4.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: import_react_query38.keepPreviousData
+  });
+};
+var useRandomTasksPerLocation = (data) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTasksPerLocation, data],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.getRandomTaskRandomtaskGet(
+        data.locationProjectId,
+        data.taskForReview,
+        null,
+        data.orderBy == "" ? null : data.orderBy,
+        data.search == "" ? null : data.search,
+        import_evoland_api_proxy4.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: import_react_query38.keepPreviousData
+  });
+};
+var useTaskComments = (taskIds) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskComment, taskIds],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.TaskService.taskLatestComomentsTasklatestcommentPost({
+        task_ids: taskIds
+      });
+    })
+  });
+};
+var useGroupsInProject = (projectId, updateGroup) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetGroupsInProject, projectId, updateGroup],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.getProjectGroupsProjectgroupsProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useProjectUsers = (projectId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetProjectUsers, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.projectAllUsersProjectusersProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTaskStatusList = () => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskStatusList],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.TaskService.getTaskStatusesTaskstatusesGet();
+    })
+  });
+};
+var useUpdateActiveGroupInProject = (projectId, groupId, update) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [
+      QueryConstants.UpdateActiveGroupsInProject,
+      projectId,
+      groupId,
+      update
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return import_evoland_api_proxy4.ProjectService.selectProjectGroupProjectselectgroupPost({
+          project_id: projectId,
+          group_id: groupId
+        });
+    })
+  });
+};
+var useTaskAnnotation = (taskId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskAnnotation, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return import_evoland_api_proxy4.TaskService.getTaskAnnotationAssetTaskannotationTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskMultipleAnnotations = (taskId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskMultipleAnnotations, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return import_evoland_api_proxy4.TaskService.getTaskAnnotationAssetsTaskannotationsTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskSavedAnnotations = (taskId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskSavedAnnotations, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== 0 && taskId !== void 0)
+        return import_evoland_api_proxy4.TaskService.getSavedAnnotationGetsavedannotationTaskIdTaskIdGet(
+          taskId
+        );
+    })
+  });
+};
+var useTaskDelete = (taskId, projectId, deleteTask) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.DeleteTask, taskId, projectId, deleteTask],
+    queryFn: () => __async(void 0, null, function* () {
+      if (taskId !== null && taskId !== void 0 && taskId !== 0 && deleteTask === true)
+        return import_evoland_api_proxy4.TaskService.deleteTaskDeletetaskPost({
+          project_id: projectId,
+          task_id: taskId
+        });
+    })
+  });
+};
+var useProjectStatisticsByUser = (projectId, startDate, endDate, filterUserId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [
+      QueryConstants.GetProjectStatisticsByUser,
+      projectId,
+      startDate,
+      endDate,
+      filterUserId
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.StatisticService.getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdGet(
+        projectId,
+        endDate,
+        startDate,
+        filterUserId
+      );
+    })
+  });
+};
+var useContractStatisticsByUser = (projectId, startDate, endDate, filterUserId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [
+      QueryConstants.GetContractStatisticsByUser,
+      projectId,
+      startDate,
+      endDate,
+      filterUserId
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.StatisticService.getUserStatisticsUserstatisticsProjectIdProjectIdStartDateStartDateEndDateEndDateFilterUserIdFilterUserIdGet(
+        projectId,
+        endDate,
+        startDate,
+        filterUserId,
+        true
+      );
+    })
+  });
+};
+var useLatestTaskOnLocation = (locationId, projectId, referenceDate) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [
+      QueryConstants.GetLatestTaskOnLocation,
+      locationId,
+      projectId,
+      referenceDate
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.locationLatestTaskLocationtaskLocationIdLocationIdProjectIdProjectIdReferenceDateReferenceDateGet(
+        locationId,
+        projectId,
+        referenceDate
+      );
+    })
+  });
+};
+var useAssignProjectToUser = (userRoleRequest, update) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetProjectDetails, userRoleRequest, update],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return import_evoland_api_proxy4.ProjectService.setUserRoleSetuserrolePost(userRoleRequest);
+    }),
+    enabled: !!update && !!userRoleRequest
+  });
+};
+var useGetUserProject = (user_id, fetchData) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetUserProject, user_id, fetchData],
+    queryFn: () => __async(void 0, null, function* () {
+      if (fetchData)
+        return import_evoland_api_proxy4.ProjectService.getUserRoleProjectGetuserroleprojectUserIdUserIdGet(
+          user_id
+        );
+    })
+  });
+};
+var useUpdateUserDetail = (userDetailRequest, update) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.SetUserDetail, userDetailRequest, update],
+    queryFn: () => __async(void 0, null, function* () {
+      if (update)
+        return import_evoland_api_proxy4.ProjectService.setUserDetailSetuserdetailPost(userDetailRequest);
+    })
+  });
+};
+var useProjectsPointsDownload = (projectId, download, userRole) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [
+      QueryConstants.DownlaodProjectsPoints,
+      projectId,
+      download,
+      userRole
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      if (userRole == "admin" && download)
+        return import_evoland_api_proxy4.ProjectService.getLocationsSummaryLocationssummaryProjectIdProjectIdGet(
+          projectId
+        );
+    })
+  });
+};
+var useQuestionnaire = (projectId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetQuestionnaireForProject, projectId],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.QuestionService.getProjectQuestionsAnswersQuestionsAnswersProjectIdProjectIdGet(
+        projectId
+      );
+    })
+  });
+};
+var useTaskAnswers = (taskId) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetTaskAnswers, taskId],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.TaskService.getTaskAnswersTaskanswersTaskIdTaskIdGet(taskId);
+    })
+  });
+};
+var useProjectResultSet = (download, projectId, is_geo_json) => {
+  return (0, import_react_query38.useQuery)({
+    queryKey: [QueryConstants.GetProjectResultSet, download, projectId, is_geo_json],
+    queryFn: () => __async(void 0, null, function* () {
+      return import_evoland_api_proxy4.ProjectService.projectResultSetProjectresultsetProjectIdProjectIdIsGeoJsonIsGeoJsonGet(projectId, is_geo_json);
+    }),
+    enabled: !!download && !!projectId
+  });
+};
+
+// src/hooks/useApiImage.tsx
+var import_react_query39 = require("@tanstack/react-query");
+var useApiImage = (imageId) => {
+  return (0, import_react_query39.useQuery)({
+    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
+var import_react_query40 = require("@tanstack/react-query");
+var useCmsImage = (imageId) => {
+  return (0, import_react_query40.useQuery)({
+    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
+var import_api_proxy26 = require("@geowiki/api-proxy");
+var import_react_query41 = require("@tanstack/react-query");
+var useClusterGetJoinRequests = (clusterId) => {
+  return (0, import_react_query41.useQuery)({
+    queryKey: [QueryNames.JoinRequests, clusterId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy26.ClusterService.clusterGetJoinRequests(clusterId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterGetNews.ts
+var import_api_proxy27 = require("@geowiki/api-proxy");
+var import_react_query42 = require("@tanstack/react-query");
+var useClusterGetNews = (clusterId, newsId) => {
+  return (0, import_react_query42.useQuery)({
+    queryKey: [QueryNames.ClusterGetNews, clusterId, newsId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy27.ClusterService.clusterGetNews(clusterId, newsId);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterGetNewsNextPreviousStatus.ts
+var import_api_proxy28 = require("@geowiki/api-proxy");
+var import_react_query43 = require("@tanstack/react-query");
+var useClusterGetNewsNextPreviousStatus = (clusterId, newsId) => {
+  return (0, import_react_query43.useQuery)({
+    queryKey: [QueryNames.ClusterNewsNextPrevious, clusterId, newsId],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy28.ClusterService.clusterGetNewsNextPreviousStatus(
+        clusterId,
+        newsId
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterImages.ts
+var import_api_proxy29 = require("@geowiki/api-proxy");
+var import_react_query44 = require("@tanstack/react-query");
+var useClusterImages = (id) => {
+  return (0, import_react_query44.useQuery)({
+    queryKey: [QueryNames.ClusterImages, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy29.ClusterService.clusterGetClusterImages(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterOverview.ts
+var import_api_proxy30 = require("@geowiki/api-proxy");
+var import_react_query45 = require("@tanstack/react-query");
+var useClusterOverview = (id) => {
+  return (0, import_react_query45.useQuery)({
+    queryKey: [QueryNames.GetClusterOverview, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy30.ClusterService.clusterGetClusterOverview(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterAllNews.ts
+var import_api_proxy31 = require("@geowiki/api-proxy");
+var import_react_query46 = require("@tanstack/react-query");
+var useClusterAllNews = (id, refresh, sorting, skipCount, maxResultCount, status) => {
+  return (0, import_react_query46.useQuery)({
+    queryKey: [
+      QueryNames.ClusterAllNews,
+      id,
+      sorting,
+      skipCount,
+      maxResultCount,
+      refresh,
+      status
+    ],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy31.ClusterService.clusterGetAllNews(
+        id,
+        sorting,
+        skipCount,
+        maxResultCount,
+        status
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useNewsFromAllClusters.ts
+var import_api_proxy32 = require("@geowiki/api-proxy");
+var import_react_query47 = require("@tanstack/react-query");
+var useNewsFromAllClusters = (skip = 0, take = 10) => {
+  return (0, import_react_query47.useQuery)({
+    queryKey: [QueryNames.ClusterAllNews, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy32.ClusterService.clusterGetAllNewsFromAllClusters(
+        "",
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterNewsWithId.ts
+var import_api_proxy33 = require("@geowiki/api-proxy");
+var import_react_query48 = require("@tanstack/react-query");
+var useClusterNewsWithId = (id) => {
+  return (0, import_react_query48.useQuery)({
+    queryKey: [QueryNames.ClusterNewsWithId, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy33.ClusterService.clusterGetClusterNewsById(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useMapMenuItems.ts
+var import_react_query49 = require("@tanstack/react-query");
+
+// src/utils/CmsApi.ts
+var import_cms_proxy7 = require("@geowiki/cms-proxy");
+var getGeoWikiSettings = () => __async(void 0, null, function* () {
+  const req = yield import_cms_proxy7.SettingsService.settingsGetSiteSettings("GeoWiki");
+  return req;
+});
+var getDefaultSettings = () => __async(void 0, null, function* () {
+  const req = yield import_cms_proxy7.SettingsService.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 import_cms_proxy7.QueryApiService.apiQueryGet(
+    "GetContentByTypeAndDisplayText",
+    `${JSON.stringify({ contenttype: contentType, displaytext: displayName })}`
+  );
+});
+var getContentWithSlug = (slug) => __async(void 0, null, function* () {
+  const req = yield import_cms_proxy7.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 import_cms_proxy7.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 (0, import_react_query49.useQuery)({
+    queryKey: [QueryNames.MapMenuItems],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield getContentsWithType("MapMenuItem");
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterLinks.ts
+var import_api_proxy34 = require("@geowiki/api-proxy");
+var import_react_query50 = require("@tanstack/react-query");
+var useClusterLinks = (id) => {
+  return (0, import_react_query50.useQuery)({
+    queryKey: [QueryNames.GetSocialLinks, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy34.ClusterService.clusterGetLinksAndPartner(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useCmsContentWithType.ts
+var import_react_query51 = require("@tanstack/react-query");
+var useCmsContentWithType = (contentType) => {
+  return (0, import_react_query51.useQuery)({
+    queryKey: [QueryNames.GetCmsContentWithType],
+    queryFn: () => __async(void 0, null, function* () {
+      const req = yield getContentsWithType(contentType);
+      return req;
+    })
+  });
+};
+
+// src/hooks/useClusterNews.ts
+var import_api_proxy35 = require("@geowiki/api-proxy");
+var import_react_query52 = require("@tanstack/react-query");
+var useClusterNews = (id, sort = "", skip = 0, take = 100) => {
+  return (0, import_react_query52.useQuery)({
+    queryKey: [QueryNames.ClusterNews, id, sort, skip, take],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy35.ClusterService.clusterGetClusterNews(
+        id,
+        sort,
+        skip,
+        take
+      );
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterDescription.ts
+var import_api_proxy36 = require("@geowiki/api-proxy");
+var import_react_query53 = require("@tanstack/react-query");
+var useClusterDescription = (id) => {
+  return (0, import_react_query53.useQuery)({
+    queryKey: [QueryNames.GetClusterDescription, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy36.ClusterService.clusterGetClusterDescription(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterDetails.ts
+var import_api_proxy37 = require("@geowiki/api-proxy");
+var import_react_query54 = require("@tanstack/react-query");
+var useClusterDetails = (id) => {
+  return (0, import_react_query54.useQuery)({
+    queryKey: [QueryNames.GetClusterDetails, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy37.ClusterService.clusterGetClusterDetails(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useClusterImagesAndVideos.ts
+var import_api_proxy38 = require("@geowiki/api-proxy");
+var import_react_query55 = require("@tanstack/react-query");
+var useClusterImagesAndVideos = (id) => {
+  return (0, import_react_query55.useQuery)({
+    queryKey: [QueryNames.GetImagesAndVideos, id],
+    queryFn: () => __async(void 0, null, function* () {
+      const data = yield import_api_proxy38.ClusterService.clusterGetImagesAndVideos(id);
+      return data;
+    })
+  });
+};
+
+// src/hooks/useHost.ts
+var import_react_query56 = require("@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 (0, import_react_query56.useQuery)({
+    queryKey: [QueryNames.GetHost],
+    queryFn: getHost
+  });
+}
+
+// src/hooks/useHostManagement.ts
+var import_react_query57 = require("@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 = (0, import_react_query57.useQueryClient)();
+  return (0, import_react_query57.useMutation)({
+    mutationFn: createHost,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHosts] });
+    }
+  });
+};
+var useUpdateHost = () => {
+  const queryClient = (0, import_react_query57.useQueryClient)();
+  return (0, import_react_query57.useMutation)({
+    mutationFn: updateHost,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHosts] });
+      queryClient.invalidateQueries({ queryKey: [QueryNames.GetHost] });
+    }
+  });
+};
+var useDeleteHost = () => {
+  const queryClient = (0, import_react_query57.useQueryClient)();
+  return (0, import_react_query57.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
+var import_zustand = require("zustand");
+var initialState = [];
+var useBreadCrumbStore = (0, import_zustand.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
+var import_zustand2 = require("zustand");
+var useLayerStore = (0, import_zustand2.create)()((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
+var import_vanilla2 = require("zustand/vanilla");
+var settingsStore = (0, import_vanilla2.createStore)(() => ({
+  settings: null
+}));
+
+// src/stores/panel.ts
+var import_zustand3 = require("zustand");
+var usePanelStore = (0, import_zustand3.create)((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
+var import_zustand4 = require("zustand");
+var useBasfStore = (0, import_zustand4.create)((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
+var import_client = require("react-dom/client");
+var import_react_dom = require("react-dom");
+var import_next_localization = require("next-localization");
+var import_driver = require("driver.js");
+var import_driver2 = require("driver.js/dist/driver.css");
+var XLSX = __toESM(require("xlsx"));
+var i18n = (0, import_next_localization.I18n)();
+var getHtmlElementFromReactNode = (node) => {
+  const div = document.createElement("div");
+  const root = (0, import_client.createRoot)(div);
+  queueMicrotask(() => {
+    (0, import_react_dom.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 = (0, import_driver.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
+var import_outline = require("@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: import_outline.HomeIcon
+  },
+  {
+    name: "Administration",
+    icon: import_outline.WrenchIcon,
+    children: [
+      {
+        name: "Roles",
+        link: "/admin/users/roles"
+      },
+      {
+        name: "Users",
+        link: "/admin/users"
+      }
+    ],
+    roles: ["admin" /* ADMIN */]
+  },
+  {
+    name: "Tenant Management",
+    icon: import_outline.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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  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
+});