@dative-gpi/foundation-shared-services 1.0.66 → 1.0.67-map-edit

package/composables/app/index.ts

@@ -1,4 +1,5 @@
 export * from "./useAppLanguageCode";
 export * from "./useAppLanguages";
 export * from "./useAppTimeZone";
-export * from "./useAppAuthToken";
+export * from "./useAppAuthToken";
+export * from "./useAppHost";

package/composables/app/useAppHost.ts

@@ -0,0 +1,17 @@
+import { computed, ref } from "vue";
+
+const host = ref<string | undefined>(undefined);
+
+export const useAppHost = () => {
+  const setAppHost = (payload: string) => {
+    host.value = payload;
+  };
+
+  const ready = computed(() => host.value !== null);
+
+  return {
+    host,
+    ready,
+    setAppHost
+  };
+}

package/composables/app/useAppTimeZone.ts

@@ -2,6 +2,9 @@ import { computed, ref } from "vue";
 
 const timeZone = ref<string | undefined>(undefined);
 
+const currentUserOffset = ref<number | null>(null);
+const currentMachineOffset = ref<number | null>(null);
+
 export const useAppTimeZone = () => {
   const setAppTimeZone = (payload: string) => {
     timeZone.value = payload;
@@ -21,47 +24,71 @@ export const useAppTimeZone = () => {
     });
   }
 
-  const getUserOffsetName = (): string => {
+  const getUserOffsetName = (epoch: number | null = null): string => {
     const formatter = getUserFormatter();
-    const currentDate = formatter.formatToParts(new Date());
-    const timeZoneName = currentDate.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
+    const date = formatter.formatToParts(epoch ? new Date(epoch) : new Date());
+    const timeZoneName = date.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
     return timeZoneName
   }
 
-  const getUserOffset = (): number => {
-    const timeZoneName = getUserOffsetName();
+  const getUserOffset = (epoch: number | null = null): number => {
+    const timeZoneName = getUserOffsetName(epoch);
     const [hours, minutes] = timeZoneName.slice(3).split(':');
-
+    if (isNaN(parseInt(hours)) || isNaN(parseInt(minutes))) {
+      return 0;
+    }
     return (parseInt(hours) * 60 + parseInt(minutes)) * 60 * 1000;
   };
 
-  const getMachineOffsetName = (): string => {
+  const getMachineOffsetName = (epoch: number | null = null): string => {
     const formatter = getMachineFormatter();
-    const currentDate = formatter.formatToParts(new Date());
-    const timeZoneName = currentDate.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
+    const date = formatter.formatToParts(epoch ? new Date(epoch) : new Date());
+    const timeZoneName = date.find((part) => part.type === "timeZoneName")?.value || "UTC+00:00";
     return timeZoneName;
   };
 
-  const getMachineOffset = (): number => {
-    const timeZoneName = getMachineOffsetName();
+  const getMachineOffset = (epoch: number | null = null): number => {
+    const timeZoneName = getMachineOffsetName(epoch);
     const [hours, minutes] = timeZoneName.slice(3).split(':');
-
+    if (isNaN(parseInt(hours)) || isNaN(parseInt(minutes))) {
+      return 0;
+    }
     return (parseInt(hours) * 60 + parseInt(minutes)) * 60 * 1000;
   }
 
-  const getOffsetDifference = (): number => {
-    return getUserOffset() - getMachineOffset();
+  const getOffsetDifference = (epoch: number | null = null): number => {
+    return cachedUserOffset(epoch) - cachedMachineOffset(epoch);
   };
 
   const ready = computed(() => timeZone.value !== null);
 
+  const cachedUserOffset = (epoch: number | null = null): number => {
+    if (epoch === null) {
+      if (currentUserOffset.value === null) {
+        currentUserOffset.value = getUserOffset();
+      }
+      return currentUserOffset.value;
+    }
+    return getUserOffset(epoch);
+  }
+
+  const cachedMachineOffset = (epoch: number | null = null): number => {
+    if (epoch === null) {
+      if (currentMachineOffset.value === null) {
+        currentMachineOffset.value = getMachineOffset();
+      }
+      return currentMachineOffset.value;
+    }
+    return getMachineOffset(epoch);
+  }
+
   return {
     ready,
     timeZone,
     setAppTimeZone,
-    getUserOffset,
+    getUserOffset: cachedUserOffset,
     getUserOffsetName,
-    getMachineOffset,
+    getMachineOffset: cachedMachineOffset,
     getMachineOffsetName,
     getOffsetDifference,
   };

package/composables/index.ts

@@ -1,6 +1,8 @@
 export * from "./services";
 export * from "./app";
 
+export * from "./useDateFormat";
 export * from "./useFiles";
 export * from "./useFoundationShared";
-export * from "./useDateFormat";
+export * from "./useRouting";
+export * from "./useDateExpression";

package/composables/services/index.ts

@@ -1,9 +1,11 @@
 export * from "./useAuthTokens";
 export * from "./useImages";
 export * from "./useLanguages";
+export * from "./useLegalInformations";
 export * from "./useNotifications";
 export * from "./useOrganisations";
 export * from "./useTerminals";
 export * from "./useTimeZones";
 export * from "./useTranslations";
+export * from "./useUserLegalInformations";
 export * from "./useUsers"; 

package/composables/services/useLegalInformations.ts

@@ -0,0 +1,10 @@
+import { LegalInformationDetails, type LegalInformationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { ComposableFactory,  ServiceFactory } from "@dative-gpi/bones-ui";
+
+import { LEGAL_INFORMATION_CURRENT_URL } from "../../config/urls";
+
+const LegalInformationServiceFactory = {
+  ...ServiceFactory.addCustom("getCurrent", axios => axios.get(LEGAL_INFORMATION_CURRENT_URL()), (dto: LegalInformationDetailsDTO) => new LegalInformationDetails(dto))
+};
+
+export const useCurrentLegalInformation = ComposableFactory.custom(LegalInformationServiceFactory.getCurrent);

package/composables/services/useUserLegalInformations.ts

@@ -0,0 +1,11 @@
+import { type CreateUserLegalInformationDTO, UserLegalInformationDetails, type UserLegalInformationDetailsDTO } from "@dative-gpi/foundation-shared-domain/models";
+import { ComposableFactory, ServiceFactory } from "@dative-gpi/bones-ui/core";
+
+import { USER_LEGAL_INFORMATIONS_URL } from "../../config/urls";
+
+const UserLegalInformationServiceFactory = new ServiceFactory<UserLegalInformationDetailsDTO, UserLegalInformationDetails>("userLegalInformation", UserLegalInformationDetails).create(factory => factory.build(
+  factory.addCreate<CreateUserLegalInformationDTO>(USER_LEGAL_INFORMATIONS_URL),
+  factory.addNotify()
+));
+
+export const useCreateUserLegalInformation = ComposableFactory.create(UserLegalInformationServiceFactory);

package/composables/useDateExpression.ts

@@ -0,0 +1,138 @@
+import { useAppTimeZone } from './app/useAppTimeZone';
+import { useDateFormat } from '@dative-gpi/foundation-shared-services/composables/useDateFormat';
+
+export const useDateExpression = () => {
+  const { getOffsetDifference } = useAppTimeZone();
+  const { parseForPicker } = useDateFormat();
+
+  const EXPRESSION = /(?:(?:([-\+])(\d*))?(\w+))?(?:\/(\w))?/g;
+  const NOW = 'now';
+
+  const convert = (value: string, variables: { [key: string]: number | string } = {}): number => {
+    //Try to convert the value to a date
+    const date = parseForPicker(value);
+    if (date) {
+      return date;
+    }
+
+    const currentVariables = {
+      ...variables,
+      [NOW]: new Date().getTime()
+    };
+
+    return applyFormula(value, currentVariables);
+  }
+
+  const applyFormula = (expression: string, variables: { [key: string]: number | string }): number => {
+    expression = expression.replace(/\s/g, '');
+    const matches = expression.matchAll(EXPRESSION);    
+
+    if (!matches) {
+      console.error('Invalid expression');
+      return NaN;
+    }
+
+    let timestamp = 0;
+
+    // Retrieving group in order are: operator (+ or -), number, unit, and special (variable)
+    matches.forEach(match => {
+      const operator = match[1];
+      const number = match[2];
+      const unit = match[3];
+      const special = match[4];
+
+      if (unit) {
+        timestamp = applyUnit(timestamp, operator, number, unit, variables);
+      }
+
+      if (special) {
+        timestamp = applySpecial(timestamp, special);
+      }
+    });
+
+    return timestamp;
+  }
+
+  const applyUnit = (timestamp: number, operator: string, number: string, unit: string, variables: { [key: string]: number | string }): number => {
+    let factor = operator === '-' ? -1 : 1;
+    factor *= Number.isNaN(parseInt(number)) ? 1 : parseInt(number);
+
+    switch (unit) {
+      case 's':
+        return timestamp + factor * 1000;
+      case 'm':
+        return timestamp + factor * 60 * 1000;
+      case 'h':
+        return timestamp + factor * 60 * 60 * 1000;
+      case 'd':
+        return new Date(timestamp).setDate(new Date(timestamp).getDate() + factor)
+      case 'w':
+        return new Date(timestamp).setDate(new Date(timestamp).getDate() + factor * 7);
+      case 'M':
+        return new Date(timestamp).setMonth(new Date(timestamp).getMonth() + factor);
+      case 'y':
+        return new Date(timestamp).setFullYear(new Date(timestamp).getFullYear() + factor);
+      default:
+        if(variables[unit]) {
+          const variableValue = getVariableValue(unit, variables);
+          return timestamp + factor * variableValue;
+        }
+        else {
+          console.error(`Invalid unit expression, unit ${unit} is not defined in the variables`);
+          return timestamp;
+        }
+    }
+  }
+
+  const getVariableValue = (unit: string, variables: { [key: string]: number | string }): number => {
+    if(variables[unit]) {
+      const variableValue = parseInt(variables[unit].toString());
+      if (typeof variables[unit] === 'number') {
+        return variableValue;
+      } else if (!isNaN(variableValue)) {
+        return variableValue;
+      } else {
+        const variableExpression = variables[unit].toString();
+        const variableValue = applyFormula(variableExpression, variables);
+        if (!isNaN(variableValue)) {
+          return variableValue;
+        } else {
+          console.error(`Invalid unit expression, unit ${unit} is not defined in the variables`);
+          return 0;
+        }
+      }
+    }
+    else {
+      console.error(`Invalid unit expression, unit ${unit} is not defined in the variables`);
+      return 0;
+    }
+  }
+
+  const applySpecial = (timestamp: number, special: string): number => {    
+    timestamp += getOffsetDifference(timestamp);
+    switch (special) {
+      case "h":
+        return new Date(timestamp).setMinutes(0, 0, 0) - getOffsetDifference(timestamp);
+      case "d":
+        return new Date(timestamp).setHours(0, 0, 0, 0) - getOffsetDifference(timestamp);
+      case "w":
+        const date = new Date(timestamp);
+        const day = date.getDay();
+        const diff = date.getDate() - day + (day === 0 ? -6 : 1);
+        return new Date(date.setDate(diff)).setHours(0, 0, 0, 0) - getOffsetDifference(timestamp);
+      case "M":
+        const dateM = new Date(timestamp);
+        return new Date(dateM.setMonth(dateM.getMonth(), 1)).setHours(0, 0, 0, 0) - getOffsetDifference(timestamp);
+      case "y":
+        const dateY = new Date(timestamp);
+        return new Date(dateY.setMonth(0, 1)).setHours(0, 0, 0, 0) - getOffsetDifference(timestamp);
+      default:
+        break;
+    }
+    return timestamp;
+  }
+
+  return {
+    convert
+  }
+}

package/composables/useDateFormat.ts

@@ -9,7 +9,7 @@ export const useDateFormat = () => {
   const { $tr } = useTranslationsProvider();
 
   const { languageCode } = useAppLanguageCode();
-  const { timeZone, getOffsetDifference, getMachineOffset, getUserOffset } = useAppTimeZone();
+  const { timeZone, getOffsetDifference, getMachineOffset } = useAppTimeZone();
 
   const isEpochToday = (value: number | null | undefined): boolean => {
     if (value == null || !isFinite(value)) {
@@ -43,6 +43,14 @@ export const useDateFormat = () => {
     return date.toLocaleString(languageCode.value, { ...OPTIONS.dayMonthLongOnly, timeZone: timeZone.value });
   }
 
+  const epochToDayMonthShortOnly = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.dayMonthShortOnly, timeZone: timeZone.value });
+  }
+
   const epochToShortDateFormat = (value: number | null | undefined): string => {
     if (value == null || !isFinite(value)) {
       return "";
@@ -57,10 +65,10 @@ export const useDateFormat = () => {
     }
     const date = new Date(value);
     if (isEpochToday(value)) {
-      return $tr("ui.time-zone.today", "Today");
+      return $tr("ui.common.today", "Today");
     }
     if (isEpochYesterday(value)) {
-      return $tr("ui.time-zone.yesterday", "Yesterday");
+      return $tr("ui.common.yesterday", "Yesterday");
     }
     const dateString = date.toLocaleString(languageCode.value, { ...OPTIONS.longDate, timeZone: timeZone.value });
     return dateString[0].toLocaleUpperCase() + dateString.slice(1);
@@ -74,6 +82,14 @@ export const useDateFormat = () => {
     return date.toLocaleString(languageCode.value, { ...OPTIONS.shortTime, timeZone: timeZone.value });
   };
 
+  const epochToMonthShortTimeFormat = (value: number | null | undefined): string => {
+    if (value == null || !isFinite(value)) {
+      return "";
+    }
+    const date = new Date(value);
+    return date.toLocaleString(languageCode.value, { ...OPTIONS.monthShortTime, timeZone: timeZone.value });
+  };
+
   const epochToLocalDayStart = (value: number | null | undefined): number => {
     if (value == null || !isFinite(value)) {
       return 0;
@@ -96,10 +112,10 @@ export const useDateFormat = () => {
     }
     const date = new Date(value);
     if (isEpochToday(value)) {
-      return `${$tr("ui.time-zone.today-at", "Today at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
+      return `${$tr("ui.common.today-at", "Today at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
     }
     if (isEpochYesterday(value)) {
-      return `${$tr("ui.time-zone.yesterday-at", "Yesterday at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
+      return `${$tr("ui.common.yesterday-at", "Yesterday at")} ${date.toLocaleString(languageCode.value, { ...OPTIONS.time, timeZone: timeZone.value })}`;
     }
     const dateString = date.toLocaleString(languageCode.value, { ...OPTIONS.longTime, timeZone: timeZone.value });
     return dateString[0].toLocaleUpperCase() + dateString.slice(1);
@@ -146,14 +162,14 @@ export const useDateFormat = () => {
 
   const pickerToEpoch = (value: Date | null | undefined): number => {
     if (value != null) {
-      return value.getTime() - getOffsetDifference();
+      return value.getTime() - getOffsetDifference(value.getTime());
     }
     return 0;
   };
 
   const epochToPicker = (value: number | null | undefined): Date => {
     if (value != null) {
-      return new Date(value + getOffsetDifference());
+      return new Date(value + getOffsetDifference(value));
     }
     return new Date(0);
   };
@@ -174,22 +190,27 @@ export const useDateFormat = () => {
   };
 
   const yesterdayToPicker = (): string => {
-    const date = addMilliseconds(subDays(new Date(), 1), -getMachineOffset());
+    const yesterday = subDays(new Date(), 1);
+    const date = addMilliseconds(yesterday, -getMachineOffset(yesterday.getTime()));
     date.setSeconds(0, 0);
     return format(date, ISO_FORMAT);
   };
 
   const parseForPicker = (value: string, dateFormat: string = ISO_FORMAT): number | null => {
-    const date = addMilliseconds(parse(value, dateFormat, new Date()), getUserOffset());
-    if (!isFinite(date.getTime())) {
+    // parse the date with the machine's current timezone. The last parameter is used to fill the gaps in the date string
+    const dateWithoutCorrection = parse(value, dateFormat, new Date());
+    if (!isFinite(dateWithoutCorrection.getTime())) {
       return null;
     }
+    // check if the timezone at the time of the date is different from the current machine timezone
+    // adjust if needed (this is the case when the date is at summer time and the machine is at winter time, for example)
+    const date = addMilliseconds(dateWithoutCorrection, getMachineOffset(dateWithoutCorrection.getTime()));
     return date.getTime();
   };
 
-  const epochToISO = (date: number | null): string => {
-    if (date != null) {
-      return format(date - getMachineOffset(), ISO_FORMAT);
+  const epochToISO = (epoch: number | null): string => {
+    if (epoch != null) {
+      return format(epoch - getMachineOffset(epoch), ISO_FORMAT);
     }
     return "";
   };
@@ -208,6 +229,8 @@ export const useDateFormat = () => {
     epochToMonthYearOnlyFormat,
     epochToShortDateFormat,
     epochToShortTimeFormat,
+    epochToDayMonthShortOnly,
+    epochToMonthShortTimeFormat,
     epochToShortTimeOnlyFormat,
     epochToTimeOnlyFormat,
     epochToWeekNumber,

package/composables/useFiles.ts

@@ -1,8 +1,13 @@
 import { FILE_URL } from "../config/urls";
 
+import { useAppAuthToken, useRouting } from "@dative-gpi/foundation-shared-services/composables";
+
 export const useFiles = () => {
+  const { authToken } = useAppAuthToken();
+  const { openTab } = useRouting();
+
   const downloadFile = (id: string): void => {
-    window.open(FILE_URL(id), "_blank");
+    openTab(FILE_URL(id, authToken.value));
   };
 
   const readFile = (file: File): Promise<string | ArrayBuffer | null> => {

package/composables/useRouting.ts

@@ -0,0 +1,37 @@
+import { type RouteLocation, useRouter } from "vue-router";
+
+import { useAppHost } from "@dative-gpi/foundation-shared-services/composables";
+
+export const useRouting = () => {
+  const { host } = useAppHost();
+  const router = useRouter();
+
+  const handleRoutingEvent = (event: MouseEvent, target: string | RouteLocation, handleDefaultBehavior: boolean = false): void => {
+    // If a redirection is requested, check if it comes from an extension and act accordingly
+    if (event.ctrlKey || event.metaKey || event.button === 1) {
+      event.preventDefault();
+      openTab(target);
+    }
+    else if (handleDefaultBehavior) {
+      router.push(target);
+    }
+  };
+
+  const openTab = (target: string | RouteLocation): void => {
+    // Check if target is a href (string) or a to (RouteLocation), get the absolute url in either case
+    const href = typeof target === "string" ? target : router.resolve(target).href;
+
+    // If the app is in an iframe, open the link in a new tab with the parent iframe host
+    if (window.top != window.self && host.value) {
+      window.open(host.value + href, "_blank");
+    }
+    else {
+      window.open(href, "_blank");
+    }
+  };
+
+  return {
+    handleRoutingEvent,
+    openTab
+  };
+}

package/config/urls/files.ts

@@ -1,4 +1,10 @@
 import { GATEWAY_URL } from "./base";
 
 export const FILES_URL = () => `${GATEWAY_URL()}/files`;
-export const FILE_URL = (fileId: string) => `${FILES_URL()}/${encodeURIComponent(fileId)}`;
+export const FILE_URL = (fileId: string, accessToken?: string) => {
+  let url = `${FILES_URL()}/${encodeURIComponent(fileId)}`;
+  if (accessToken) {
+    url += `?access_token=${encodeURIComponent(accessToken)}`;
+  }
+  return url;
+};

package/config/urls/images.ts

@@ -3,17 +3,17 @@ import { GATEWAY_URL } from "./base";
 export const IMAGES_URL = () => `${GATEWAY_URL()}/images`;
 
 export const IMAGE_URL = (imageId: string) => `${IMAGES_URL()}/${encodeURIComponent(imageId)}`;
-export const IMAGE_RAW_URL = (imageId: string, authToken?: string) => {
+export const IMAGE_RAW_URL = (imageId: string, accessToken?: string) => {
   let url = `${IMAGE_URL(imageId)}/raw`;
-  if (authToken) {
-    url += `?authToken=${encodeURIComponent(authToken)}`;
+  if (accessToken) {
+    url += `?access_token=${encodeURIComponent(accessToken)}`;
   }
   return url;
 };
-export const IMAGE_THUMBNAIL_URL = (imageId: string, authToken?: string) => {
+export const IMAGE_THUMBNAIL_URL = (imageId: string, accessToken?: string) => {
   let url = `${IMAGE_URL(imageId)}/thumbnail`;
-  if (authToken) {
-    url += `?authToken=${encodeURIComponent(authToken)}`;
+  if (accessToken) {
+    url += `?access_token=${encodeURIComponent(accessToken)}`;
   }
   return url;
 };

package/config/urls/index.ts

@@ -2,9 +2,11 @@ export * from "./authTokens";
 export * from "./files";
 export * from "./images";
 export * from "./languages";
+export * from "./legalInformations";
 export * from "./notifications";
 export * from "./organisations";
 export * from "./terminals";
 export * from "./timeZones";
 export * from "./translations";
+export * from "./userLegalInformations";
 export * from "./users";

package/config/urls/legalInformations.ts

@@ -0,0 +1,4 @@
+import { GATEWAY_URL } from "./base";
+
+export const LEGAL_INFORMATIONS_URL = () => `${GATEWAY_URL()}/legal-informations`;
+export const LEGAL_INFORMATION_CURRENT_URL = () => `${LEGAL_INFORMATIONS_URL()}/current`;

package/config/urls/userLegalInformations.ts

@@ -0,0 +1,3 @@
+import { GATEWAY_URL } from "./base";
+
+export const USER_LEGAL_INFORMATIONS_URL = () => `${GATEWAY_URL()}/user-legal-informations`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-shared-services",
   "sideEffects": false,
-  "version": "1.0.66",
+  "version": "1.0.67-map-edit",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,13 +10,13 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "1.0.66"
+    "@dative-gpi/foundation-shared-domain": "1.0.67-map-edit"
   },
   "peerDependencies": {
-    "@dative-gpi/bones-ui": "^0.0.75",
+    "@dative-gpi/bones-ui": "^1.0.0",
     "@microsoft/signalr": "^8.0.0",
-    "vue": "^3.4.29",
+    "vue": "^3.4.38",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "84d2d567d51959856200d302f7972b04bc56675a"
+  "gitHead": "725635256ebf2bb6450c38e5a3077fb907ea550c"
 }

package/tools/hubFactory.ts

@@ -10,7 +10,7 @@ export class HubFactory {
 
         let connection: signalR.HubConnection | null = null;
         let subscribed = false;
-        let watchManySubscribers = 0;
+        const watchManySubscribers = ref(0);
         const watcheds = ref<string[]>([]);
 
         return () => {
@@ -24,7 +24,7 @@ export class HubFactory {
 
                     configureHooks(connection, {
                         isWatched: (id: string) => watcheds.value.includes(id),
-                        hasWatchers: () => watchManySubscribers > 0,
+                        hasWatchers: () => watchManySubscribers.value > 0,
                     })
                 }
                 if (connection.state !== signalR.HubConnectionState.Connected) {
@@ -48,7 +48,7 @@ export class HubFactory {
                 }
             }
 
-            const hasSubscribers = computed(() => watcheds.value.length > 0 || watchManySubscribers > 0);
+            const hasSubscribers = computed(() => watcheds.value.length > 0 || watchManySubscribers.value > 0);
 
             watch(hasSubscribers, async (value) => {
                 if (value) {
@@ -68,11 +68,11 @@ export class HubFactory {
             }
 
             const subscribeToMany = () => {
-                watchManySubscribers++;
+                watchManySubscribers.value++;
             }
 
             const unsubscribeFromMany = () => {
-                watchManySubscribers--;
+                watchManySubscribers.value--;
             }
 
             return {