@cnamts/synapse 1.0.24 → 1.0.26

package/src/components/Tables/common/TableHeader.vue

@@ -1,6 +1,6 @@
 <script setup lang="ts">
 	import { computed, nextTick, onMounted, ref, inject, watch, type Ref, onUnmounted } from 'vue'
-	import type { VDataTable, VDataTableServer } from 'vuetify/components'
+	import type { VDataTable, VDataTableServer } from 'vuetify/components/VDataTable'
 	import { locales } from './locales'
 	import SyIcon from '@/components/Customs/SyIcon/SyIcon.vue'
 
@@ -14,10 +14,12 @@
 		headerParams: Parameters<VDataTable['$slots']['headers']>['0']
 		table: VDataTable | VDataTableServer | null | undefined
 		resizableColumns?: boolean
+		wrapTitle?: boolean
 		storageKey?: string
 		headerPropsRaw?: HeaderPropsRaw
 	}>(), {
 		resizableColumns: false,
+		wrapTitle: false,
 		storageKey: undefined,
 		headerPropsRaw: undefined,
 	})
@@ -198,13 +200,27 @@
 		const index = props.headerParams.sortBy.findIndex(sort => sort.key === props.column.key)
 		return index !== -1 ? index + 1 : null
 	})
+
+	const titleClasses = computed(() => [
+		textAlignClass.value,
+		headerClassRaw.value,
+		{ 'col-title--wrap': props.wrapTitle },
+	])
+
+	const wrapperClasses = computed(() => [
+		alignClass.value,
+		{
+			'h-100': !props.wrapTitle,
+			'v-data-table-header__content--wrap': props.wrapTitle,
+		},
+	])
 </script>
 
 <template>
 	<div
 		ref="wrapper"
-		class="v-data-table-header__content d-flex align-center h-100 w-100"
-		:class="alignClass"
+		class="v-data-table-header__content d-flex align-center w-100"
+		:class="wrapperClasses"
 	>
 		<slot
 			:name="`header.${column.key}`"
@@ -216,7 +232,7 @@
 		>
 			<div
 				class="col-title"
-				:class="[textAlignClass, headerClassRaw]"
+				:class="titleClasses"
 				:style="headerStyle"
 			>
 				{{ column.title }}
@@ -268,6 +284,27 @@
 <style lang="scss" scoped>
 .v-data-table-header__content {
 	column-gap: 4px;
+	min-width: 0;
+}
+
+.v-data-table-header__content--wrap {
+	height: auto;
+}
+
+.col-title {
+	flex: 1 1 auto;
+	min-width: 0;
+}
+
+.col-title--wrap {
+	white-space: normal;
+	overflow-wrap: anywhere;
+	word-break: break-word;
+	line-height: 1.25;
+}
+
+.sort-container {
+	flex: 0 0 auto;
 }
 
 .sort-order-indicator {

package/src/components/Tables/common/filters/DateFilter.vue

@@ -2,7 +2,7 @@
 	import { computed } from 'vue'
 	import type { FilterOption, TableColumnHeader } from '../types'
 	import DatePicker from '@/components/DatePicker/CalendarMode/DatePicker.vue'
-	import type { DateValue } from '@/composables/date/useDateInitializationDayjs'
+	import type { DateModelValue } from '@/composables/date/useDateInitializationDayjs'
 	import { useDateFormat } from '@/composables/date/useDateFormatDayjs'
 	const { parseDate } = useDateFormat()
 
@@ -16,7 +16,7 @@
 			default: () => [],
 		},
 		filterValue: {
-			type: [String, Date, Object, null] as unknown as () => DateValue,
+			type: [String, Date, Object, null] as unknown as () => DateModelValue,
 			default: null,
 		},
 		inputConfig: {

package/src/components/Tables/common/filters/SelectFilter.vue

@@ -225,7 +225,7 @@
 	top: 1px;
 	left: 12px;
 	color: rgb(0 0 0 / 60%);
-	font-size: 14px;
+	font-size: var(--v-fontSize-liensEtLibelles);
 	line-height: 36px; /* Adjust based on your select height */
 	pointer-events: none;
 	width: calc(100% - 40px); /* Leave space for the dropdown icon */

package/src/components/Tables/common/locales.ts

@@ -19,6 +19,9 @@ export const locales = {
 		pageAriaLabel: (page: number) => `Page ${page}`,
 		currentPageAriaLabel: (page: number) => `Page courante, Page ${page}`,
 		paginationNavAriaLabel: 'Navigation de pagination',
+		pageInputLabel: 'Aller à la page',
+		pageInputAriaLabel: (pageCount: number) => `Aller à la page, entre 1 et ${pageCount}`,
+		pageOf: (pageCount: number) => `sur ${pageCount}`,
 	},
 	reorganizeColumns: 'Gestion des colonnes',
 	close: 'Fermer',

package/src/components/Tables/common/tableStyles.scss

@@ -1,11 +1,8 @@
-@use 'sass:color';
-@use '@/assets/tokens';
-
 @mixin tablestyles {
 	.v-table {
-		border: 1px solid tokens.$grey-lighten-80;
+		border: 1px solid rgb(var(--v-theme-grey-lighten80));
 
-		--sy-table-header-bg-pinned: #{color.mix(tokens.$blue-lighten-80, #fff, 20%)};
+		--sy-table-header-bg-pinned: color-mix(in srgb, rgb(var(--v-theme-blue-lighten80)) 20%, white);
 
 		// Standardisation des z-index pour les tableaux
 		--sy-table-z-base: 1;
@@ -20,13 +17,13 @@
 
 	table thead tr.filters,
 	table thead tr.reset {
-		background-color: tokens.$blue-lighten-90;
+		background-color: rgb(var(--v-theme-blue-lighten90));
 	}
 
 	caption,
 	table thead tr.headers,
 	table thead tr.reset {
-		background-color: rgba(tokens.$blue-lighten-80, 0.2);
+		background-color: rgba(var(--v-theme-blue-lighten80), 0.2);
 	}
 
 	&.fixed-min-height {
@@ -47,44 +44,44 @@
 			.v-field__append-inner > .v-icon,
 			.v-field__clearable > .v-icon {
 				opacity: 1;
-				color: tokens.$primary-base;
+				color: rgb(var(--v-theme-primary));
 			}
 		}
 
 		&--focused {
-			border-color: tokens.$primary-base;
-			color: tokens.$primary-base;
+			border-color: rgb(var(--v-theme-primary));
+			color: rgb(var(--v-theme-primary));
 		}
 	}
 
 	// Override Vuetify's checkbox styles to use primary color
 	.v-table .v-selection-control {
-		color: rgb(var(--v-theme-primary)) !important;
+		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
 	}
 
 	.v-table .v-selection-control--dirty .v-selection-control__input::before {
-		background-color: rgb(var(--v-theme-primary)) !important;
-		border-color: rgb(var(--v-theme-primary)) !important;
+		background-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
 	}
 
 	// Target the header checkbox specifically
 	.v-data-table-header__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-primary)) !important;
+		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
 	}
 
 	// Target the row checkboxes specifically
 	.v-data-table-row__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-primary)) !important;
+		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
 	}
 
 	// Add a global style for all checkboxes in the table
 	.v-checkbox .v-selection-control__input::before,
 	.v-checkbox-btn .v-selection-control__input::before {
-		border-color: rgb(var(--v-theme-primary)) !important;
+		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
 	}
 
 	.v-data-table-rows-no-data {
-		color: tokens.$grey-base;
+		color: rgb(var(--v-theme-grey-base));
 	}
 
 	// Ensure loading progress bar appears above sticky/pinned header cells
@@ -104,7 +101,7 @@
 
 	.v-table tbody > tr.sy-table__clickable-row:focus-visible,
 	.v-data-table__tbody > tr.sy-table__clickable-row:focus-visible {
-		outline: 2px solid tokens.$primary-base;
+		outline: 2px solid rgb(var(--v-theme-primary));
 	}
 
 	.v-table tbody > tr.sy-table__clickable-row > td,
@@ -123,6 +120,6 @@
 	.v-data-table__tbody > tr.sy-table__clickable-row:hover > .v-data-table__td,
 	.v-data-table__tbody > tr.sy-table__clickable-row:focus-visible > td,
 	.v-data-table__tbody > tr.sy-table__clickable-row:focus-visible > .v-data-table__td {
-		background-color: rgba(tokens.$primary-base, 0.08) !important;
+		background-color: rgba(var(--v-theme-primary), 0.08) !important;
 	}
 }

package/src/components/Tables/common/tests/SyTablePagination.spec.ts

@@ -135,6 +135,24 @@ describe('SyTablePagination.vue', () => {
 		expect(wrapper.emitted('update:page')![0]).toEqual([2])
 	})
 
+	it('groups page input with pagination controls', () => {
+		const wrapper = mount(SyTablePagination, {
+			props: {
+				headingLevel: 2,
+				page: 3,
+				itemsPerPage: 10,
+				itemsLength: 100,
+				pageCount: 10,
+				pageInput: true,
+			},
+		})
+
+		const controls = wrapper.find('.pagination-controls')
+		expect(controls.exists()).toBe(true)
+		expect(controls.find('.pagination').exists()).toBe(true)
+		expect(controls.find('.page-input').exists()).toBe(true)
+	})
+
 	it('has the correct structure for items per page selection', () => {
 		const wrapper = mount(SyTablePagination, {
 			props: {

package/src/components/Tables/common/tests/TableHeader.spec.ts

@@ -135,6 +135,45 @@ describe('TableHeader', () => {
 		expect(wrapper.find('.sort-order-indicator').exists()).toBe(false)
 	})
 
+	it('wraps the column title when resizable columns are enabled', () => {
+		const column = {
+			title: 'A very long column title',
+			key: 'test',
+			value: 'test',
+			sortable: true,
+		}
+
+		const wrapper = mount(TableHeader, {
+			props: {
+				column,
+				headerParams: {
+					sortBy: [],
+					getSortIcon: () => 'mdi-arrow-up',
+					toggleSort: () => {},
+					columns: [
+						{
+							key: 'test',
+							value: 'test',
+							title: 'A very long column title',
+							sortable: true,
+						},
+					],
+					headers: [],
+					someSelected: false,
+					allSelected: false,
+					selectAll: () => {},
+					isSorted: () => false,
+				},
+				table: { $el: { offsetWidth: 800 } } as unknown as VDataTable,
+				wrapTitle: true,
+			},
+		})
+
+		expect(wrapper.find('.col-title').classes()).toContain('col-title--wrap')
+		expect(wrapper.find('.v-data-table-header__content').classes()).toContain('v-data-table-header__content--wrap')
+		expect(wrapper.find('.v-data-table-header__content').classes()).not.toContain('h-100')
+	})
+
 	// Test for correct sort order when multiple columns are sorted
 	it('displays correct sort order numbers for multiple sorted columns', async () => {
 		const columns = [

package/src/components/Tables/common/types.ts

@@ -105,6 +105,7 @@ export type SyTableProps = {
 	pinnedColumns?: Array<string | { key: string, side?: 'left' | 'right' }>
 	pinnedColumnKey?: string
 	clickableRow?: boolean
+	pageInput?: boolean
 }
 
 export type SyServerTableProps = {
@@ -132,4 +133,5 @@ export type SyServerTableProps = {
 	pinnedColumns?: Array<string | { key: string, side?: 'left' | 'right' }>
 	pinnedColumnKey?: string
 	clickableRow?: boolean
+	pageInput?: boolean
 }

package/src/components/Tables/common/useTableHeaders.ts

@@ -18,8 +18,38 @@ export function useTableHeaders({
 	storedHeaders?: DataTableHeaders[]
 	filterInputConfig?: Record<string, unknown>
 }) {
-	// Process headers to ensure they have title property
-	const normalizedHeaders = computed(() => {
+	function normalizeHeader(header: DataTableHeaders): DataTableHeaders {
+		const mapped = {
+			...header,
+			title: header.title ?? header.text,
+		} as TableColumnHeader
+
+		// Si maxWidth est défini sans width → applique-le à width
+		if (mapped.maxWidth != null && mapped.width == null) {
+			mapped.width = mapped.maxWidth
+		}
+
+		// Si maxWidth est défini → l'appliquer aussi aux <td> via cellProps
+		if (mapped.maxWidth != null) {
+			const existingCellProps = (mapped.cellProps ?? {}) as Record<string, unknown>
+			const existingStyle = (existingCellProps.style ?? {}) as Record<string, unknown>
+			const multilineStyle = {
+				...existingStyle,
+				maxWidth: mapped.maxWidth,
+				whiteSpace: 'normal',
+				overflowWrap: 'anywhere',
+				wordBreak: 'break-word',
+			}
+			const baseProps = { ...existingCellProps, style: multilineStyle }
+			mapped.cellProps = () => ({
+				...baseProps,
+			})
+		}
+
+		return mapped as unknown as DataTableHeaders
+	}
+
+	const mergedHeaders = computed(() => {
 		const incoming = headersProp?.value
 		const stored = Array.isArray(storedHeaders) ? storedHeaders : undefined
 
@@ -61,27 +91,11 @@ export function useTableHeaders({
 			headers = (stored ?? incoming) as DataTableHeaders[]
 		}
 
-		// Normalisation finale
-		return headers.map((header) => {
-			const mapped = {
-				...header,
-				title: header.title ?? header.text,
-			} as TableColumnHeader
-
-			// Si maxWidth est défini sans width → applique-le à width
-			if (mapped.maxWidth != null && mapped.width == null) {
-				mapped.width = mapped.maxWidth
-			}
-
-			return mapped as unknown as DataTableHeaders
-		})
+		return headers
 	})
 
-	// Get filterable headers
-	const filterableHeaders = computed(() => {
-		if (!normalizedHeaders.value) return []
-		return normalizedHeaders.value.filter(header => header.filterable)
-	})
+	// Process headers to ensure they have title property and regenerate cellProps after reordering
+	const normalizedHeaders = computed(() => mergedHeaders.value?.map(normalizeHeader))
 
 	/**
 	 * Enhance header with filter type and configuration
@@ -112,27 +126,35 @@ export function useTableHeaders({
 		internalHeaders.value = newHeaders
 	}, { immediate: true, deep: true })
 
+	const normalizedInternalHeaders = computed(() => internalHeaders.value?.map(normalizeHeader))
+
+	// Get filterable headers
+	const filterableHeaders = computed(() => {
+		if (!normalizedInternalHeaders.value) return []
+		return normalizedInternalHeaders.value.filter(header => header.filterable)
+	})
+
 	/**
 	 * Get header by key
 	 */
 	function getHeaderByKey(key: string): TableColumnHeader | undefined {
-		return normalizedHeaders.value?.find(header => header.key === key)
+		return normalizedInternalHeaders.value?.find(header => header.key === key)
 	}
 
 	/**
 	 * Get original header from a rendered column (match by key or value)
 	 */
 	function getHeaderForColumn(column: TableColumnHeader): TableColumnHeader | undefined {
-		if (!normalizedHeaders.value) return undefined
+		if (!normalizedInternalHeaders.value) return undefined
 		const key = column.key ?? undefined
 		if (key) {
-			const byKey = normalizedHeaders.value.find(h => h.key === key)
+			const byKey = normalizedInternalHeaders.value.find(h => h.key === key)
 			if (byKey) return byKey
 		}
 		// Fallback: try matching by value when key is not present or didn't match
 		const val = typeof column.value === 'string' ? column.value : undefined
 		if (val) {
-			const byValue = normalizedHeaders.value.find(h => h.value === val)
+			const byValue = normalizedInternalHeaders.value.find(h => h.value === val)
 			if (byValue) return byValue
 		}
 		return undefined
@@ -142,8 +164,8 @@ export function useTableHeaders({
 	 * The headers filtered by visibility and sorted by order
 	 */
 	const displayHeaders = computed(() => {
-		if (!internalHeaders.value) return undefined
-		const filteredHeaders = internalHeaders.value.filter(header => header.hidden !== true)
+		if (!normalizedInternalHeaders.value) return undefined
+		const filteredHeaders = normalizedInternalHeaders.value.filter(header => header.hidden !== true)
 		return sortHeaders(filteredHeaders)
 	})
 

package/src/components/UploadWorkflow/UploadWorkflow.vue

@@ -30,6 +30,7 @@
 			}
 		>(),
 		{
+			uploadList: () => [],
 			sectionTitle: undefined,
 			showFilePreview: false,
 			infoText: '',

package/src/components/UploadWorkflow/tests/UploadWorkflow.spec.ts

@@ -35,6 +35,29 @@ describe('UploadWorkflow', () => {
 		expect(wrapper.find('.sy-file-upload').isVisible()).toBeTruthy()
 	})
 
+	it('handles empty upload list without crashing', async () => {
+		const wrapper = mount(UploadWorkflow, {
+			props: {
+				uploadList: [],
+			},
+		})
+
+		expect(wrapper.html()).toMatchSnapshot()
+		expect(wrapper.findAll('.file-item')).toHaveLength(0)
+		expect(wrapper.find('.sy-file-upload').exists()).toBeFalsy()
+	})
+
+	it('handles undefined upload list without crashing', async () => {
+		const wrapper = mount(UploadWorkflow, {
+			/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+			props: {} as any,
+		})
+
+		expect(wrapper.html()).toMatchSnapshot()
+		expect(wrapper.findAll('.file-item')).toHaveLength(0)
+		expect(wrapper.find('.sy-file-upload').exists()).toBeFalsy()
+	})
+
 	it('shows the file in the list when set with the list button', async () => {
 		const wrapper = mount(UploadWorkflow, {
 			props: {

package/src/components/UploadWorkflow/tests/__snapshots__/UploadWorkflow.spec.ts.snap

@@ -1,5 +1,71 @@
 // Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
+exports[`UploadWorkflow > handles empty upload list without crashing 1`] = `
+<div
+  class="
+    sy-upload-workflow
+    white
+  "
+  style="width: 100%;"
+>
+  <h4 class="
+    mb-2
+    sy-heading
+    text-h6
+  ">
+    Document à nous transmettre
+  </h4>
+  <ul
+    class="upload-list"
+    style="width: 100%;"
+  ></ul>
+  <transition-stub
+    appear="false"
+    css="true"
+    persisted="false"
+  >
+    <!-- v-if -->
+  </transition-stub>
+  <!---->
+  <!---->
+  <!---->
+  <!---->
+</div>
+`;
+
+exports[`UploadWorkflow > handles undefined upload list without crashing 1`] = `
+<div
+  class="
+    sy-upload-workflow
+    white
+  "
+  style="width: 100%;"
+>
+  <h4 class="
+    mb-2
+    sy-heading
+    text-h6
+  ">
+    Document à nous transmettre
+  </h4>
+  <ul
+    class="upload-list"
+    style="width: 100%;"
+  ></ul>
+  <transition-stub
+    appear="false"
+    css="true"
+    persisted="false"
+  >
+    <!-- v-if -->
+  </transition-stub>
+  <!---->
+  <!---->
+  <!---->
+  <!---->
+</div>
+`;
+
 exports[`UploadWorkflow > render the upload list 1`] = `
 <div
   class="

package/src/components/UploadWorkflow/useFileList.ts

@@ -72,6 +72,9 @@ export default function useFileList(
 	}
 
 	const filledUploadList = computed<FileItem[]>(() => {
+		if (!uploadList.value) {
+			return []
+		}
 		return uploadList.value.map((uploadItem) => {
 			const matchingUploadedItem = findSelectedFile(uploadItem.id)
 			const error = errorSelectedFiles.value.includes(uploadItem.id)

package/src/components/UserMenuBtn/UserMenuBtn.vue

@@ -94,12 +94,10 @@
 </template>
 
 <style scoped lang="scss">
-@use '@/assets/tokens';
-
 .vd-user-icon {
 	width: 40px;
 	height: 40px;
-	background: tokens.$grey-lighten-90;
+	background: rgb(var(--v-theme-grey-lighten90));
 	border-radius: 50%;
 
 	svg,

package/src/composables/date/tests/useDateFormatDayjs.spec.ts

@@ -2,7 +2,88 @@ import { describe, it, expect } from 'vitest'
 import { formatDate, parseDate } from '../useDateFormatDayjs'
 
 describe('useDateFormatDayjs', () => {
+	describe('formatDate', () => {
+		it('formats a Date object to string according to the specified format', () => {
+			const date = new Date(2023, 0, 15) // 15 janvier 2023
+			expect(formatDate(date, 'DD/MM/YYYY')).toBe('15/01/2023')
+			expect(formatDate(date, 'YYYY-MM-DD')).toBe('2023-01-15')
+		})
+
+		it('returns empty string when date is null or undefined', () => {
+			expect(formatDate(null as unknown as Date, 'DD/MM/YYYY')).toBe('')
+			expect(formatDate(undefined as unknown as Date, 'DD/MM/YYYY')).toBe('')
+		})
+
+		it('handles different date formats correctly', () => {
+			const date = new Date(2023, 11, 31) // 31 décembre 2023
+			expect(formatDate(date, 'DD/MM/YYYY')).toBe('31/12/2023')
+			expect(formatDate(date, 'YYYY-MM-DD')).toBe('2023-12-31')
+		})
+
+		it('handles custom separators correctly', () => {
+			const date = new Date(2023, 0, 15) // 15 janvier 2023
+			expect(formatDate(date, 'DD.MM.YYYY')).toBe('15.01.2023')
+			expect(formatDate(date, 'DD-MM-YYYY')).toBe('15-01-2023')
+			expect(formatDate(date, 'YYYY/MM/DD')).toBe('2023/01/15')
+		})
+	})
+
 	describe('parseDate', () => {
+		it('parses a date string to a Date object according to the specified format', () => {
+			const dateStr = '15/01/2023'
+			const date = parseDate(dateStr, 'DD/MM/YYYY')
+			expect(date).toBeInstanceOf(Date)
+			expect(date?.getFullYear()).toBe(2023)
+			expect(date?.getMonth()).toBe(0) // Janvier = 0
+			expect(date?.getDate()).toBe(15)
+		})
+
+		it('returns null for invalid date strings', () => {
+			expect(parseDate('invalid', 'DD/MM/YYYY')).toBeNull()
+			expect(parseDate('31/02/2023', 'DD/MM/YYYY')).toBeNull() // 31 février n'existe pas
+		})
+
+		it('handles different date formats correctly', () => {
+			expect(parseDate('2023-01-15', 'YYYY-MM-DD')?.getDate()).toBe(15)
+			expect(parseDate('15.01.2023', 'DD.MM.YYYY')?.getDate()).toBe(15)
+		})
+
+		it('returns null when input is null or empty', () => {
+			expect(parseDate(null, 'DD/MM/YYYY')).toBeNull()
+			expect(parseDate('', 'DD/MM/YYYY')).toBeNull()
+		})
+
+		it('handles leap years correctly', () => {
+			// 2020 était une année bissextile
+			expect(parseDate('29/02/2020', 'DD/MM/YYYY')).not.toBeNull()
+			// 2023 n'est pas une année bissextile
+			expect(parseDate('29/02/2023', 'DD/MM/YYYY')).toBeNull()
+		})
+
+		it('returns the Date object as-is when input is already a Date', () => {
+			const original = new Date(2023, 5, 15, 10, 30)
+			const result = parseDate(original, 'DD/MM/YYYY')
+			expect(result).toBe(original) // même référence
+		})
+
+		it('creates dates at midnight (00:00:00.000)', () => {
+			const date = parseDate('15/01/2023', 'DD/MM/YYYY')!
+			expect(date.getHours()).toBe(0)
+			expect(date.getMinutes()).toBe(0)
+			expect(date.getSeconds()).toBe(0)
+			expect(date.getMilliseconds()).toBe(0)
+		})
+
+		it('roundtrip: parseDate then formatDate preserves the same calendar day', () => {
+			const formats = ['DD/MM/YYYY', 'YYYY-MM-DD', 'DD.MM.YYYY']
+			const inputs = ['01/01/2023', '2023-06-30', '31.12.2020']
+			formats.forEach((fmt, i) => {
+				const parsed = parseDate(inputs[i]!, fmt)
+				expect(parsed).not.toBeNull()
+				expect(formatDate(parsed, fmt)).toBe(inputs[i])
+			})
+		})
+
 		it('keeps the same calendar day when formatting back in a negative timezone (UTC-4)', () => {
 			const previousTz = process.env.TZ
 			process.env.TZ = 'America/Guadeloupe'