@dative-gpi/foundation-shared-services 1.0.129 → 1.0.130

package/composables/app/useAppTimeZone.ts

@@ -53,8 +53,8 @@ export const useAppTimeZone = () => {
     return (parseInt(hours) * 60 + parseInt(minutes)) * 60 * 1000;
   }
 
-  const getOffsetDifference = (): number => {
-    return getUserOffset() - getMachineOffset();
+  const getOffsetDifference = (epoch: number | null = null): number => {
+    return getUserOffset(epoch) - getMachineOffset(epoch);
   };
 
   const ready = computed(() => timeZone.value !== null);

package/composables/index.ts

@@ -4,4 +4,5 @@ export * from "./app";
 export * from "./useDateFormat";
 export * from "./useFiles";
 export * from "./useFoundationShared";
-export * from "./useRouting";
+export * from "./useRouting";
+export * from "./useTermFieldDate";

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 "";
@@ -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;
@@ -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);
   };
@@ -181,10 +197,14 @@ export const useDateFormat = () => {
   };
 
   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();
   };
 
@@ -209,6 +229,8 @@ export const useDateFormat = () => {
     epochToMonthYearOnlyFormat,
     epochToShortDateFormat,
     epochToShortTimeFormat,
+    epochToDayMonthShortOnly,
+    epochToMonthShortTimeFormat,
     epochToShortTimeOnlyFormat,
     epochToTimeOnlyFormat,
     epochToWeekNumber,

package/composables/useTermFieldDate.ts

@@ -0,0 +1,138 @@
+import { useAppTimeZone } from './app/useAppTimeZone';
+import { useDateFormat } from '@dative-gpi/foundation-shared-services/composables/useDateFormat';
+
+export const useTermFieldDate = () => {
+  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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dative-gpi/foundation-shared-services",
   "sideEffects": false,
-  "version": "1.0.129",
+  "version": "1.0.130",
   "description": "",
   "publishConfig": {
     "access": "public"
@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@dative-gpi/foundation-shared-domain": "1.0.129"
+    "@dative-gpi/foundation-shared-domain": "1.0.130"
   },
   "peerDependencies": {
     "@dative-gpi/bones-ui": "^1.0.0",
@@ -18,5 +18,5 @@
     "vue": "^3.4.38",
     "vue-router": "^4.3.0"
   },
-  "gitHead": "73ebbdb8cfd158e2748933ec57315bc1b5fc4835"
+  "gitHead": "fc680c25f1b54df6a7c9195343556c0c93f1454d"
 }