integration-web-core--socle 1.4.2

package/cdp-due--customer-space-module-master/src/components/text-expand/TextExpand.vue

@@ -0,0 +1,31 @@
+<script setup>
+	import ShowMoreLink from '@/components/show-more-link/ShowMoreLink.vue';
+
+	import { useTextExpand } from './textExpand.composable';
+
+	const props = defineProps({
+		text: {
+			type: String,
+			required: true,
+		},
+		limit: {
+			type: Number,
+			required: true,
+		},
+	});
+
+	const { onExpand, isTrimmed, computedText, isExpanded } = useTextExpand(
+		props.text,
+		props.limit,
+	);
+</script>
+
+<template>
+	<div>
+		<p>
+			{{ computedText }}
+		</p>
+
+		<ShowMoreLink v-if="isTrimmed" :is-expanded="isExpanded" @click="onExpand" />
+	</div>
+</template>

package/cdp-due--customer-space-module-master/src/components/text-expand/__tests__/textExpand.rules.test.js

@@ -0,0 +1,37 @@
+import { TextExpandRules } from '../textExpand.rules';
+
+const textExpandRulesTest = new TextExpandRules();
+
+describe('textExpandRules', () => {
+	describe('Whether text must be trimmed or not', () => {
+		it('should not be trimmed if there is no limit', () => {
+			expect(textExpandRulesTest.isTrimmed('text', 0)).toBe(false);
+			expect(textExpandRulesTest.isTrimmed('text', undefined)).toBe(false);
+		});
+
+		it('should not be trimmed if text is shorter than limit', () => {
+			expect(textExpandRulesTest.isTrimmed('text', 10)).toBe(false);
+		});
+
+		it('should be trimmed if text is longer than limit', () => {
+			expect(textExpandRulesTest.isTrimmed('this is a long text', 10)).toBe(true);
+		});
+	});
+
+	describe('Which text to display', () => {
+		it('should return original text if text is not trimmed', () => {
+			expect(textExpandRulesTest.getText('text', 0, false, false)).toBe('text');
+			expect(textExpandRulesTest.getText('text', 0, false, true)).toBe('text');
+			expect(textExpandRulesTest.getText('text', 10, false, true)).toBe('text');
+		});
+
+		it('should return original text if text is trimmed and expanded', () => {
+			expect(textExpandRulesTest.getText('text', 0, true, true)).toBe('text');
+			expect(textExpandRulesTest.getText('text', 10, true, true)).toBe('text');
+		});
+
+		it('should return trimmed text if text is trimmed and not expanded', () => {
+			expect(textExpandRulesTest.getText('text', 2, true, false)).toBe('te...');
+		});
+	});
+});

package/cdp-due--customer-space-module-master/src/components/text-expand/textExpand.composable.js

@@ -0,0 +1,25 @@
+import { computed, ref } from 'vue';
+
+import { textExpandRules } from './textExpand.rules';
+
+export function useTextExpand(text, limit) {
+	const isExpanded = ref(false);
+
+	function onExpand(event) {
+		event.preventDefault();
+		isExpanded.value = !isExpanded.value;
+	}
+
+	const isTrimmed = computed(() => textExpandRules.isTrimmed(text, limit));
+
+	const computedText = computed(() =>
+		textExpandRules.getText(text, limit, isTrimmed.value, isExpanded.value),
+	);
+
+	return {
+		onExpand,
+		isTrimmed,
+		computedText,
+		isExpanded,
+	};
+}

package/cdp-due--customer-space-module-master/src/components/text-expand/textExpand.rules.js

@@ -0,0 +1,14 @@
+export class TextExpandRules {
+	isTrimmed(text, limit) {
+		return !!(limit && text.length > limit);
+	}
+
+	getText(text, limit, isTrimmed, isExpanded) {
+		if (isTrimmed && !isExpanded) {
+			return `${text.substring(0, limit)}...`;
+		}
+		return text;
+	}
+}
+
+export const textExpandRules = new TextExpandRules();

package/cdp-due--customer-space-module-master/src/composables/useAdminSearchCustomers.js

@@ -0,0 +1,11 @@
+import { computed } from 'vue';
+
+import { getCustomersSearchResult } from '@/contents/admin/module/getters';
+
+export default function useCustomersResult() {
+	const customersResult = computed(() => getCustomersSearchResult());
+
+	return {
+		customersResult,
+	};
+}

package/cdp-due--customer-space-module-master/src/composables/useBuComponent.js

@@ -0,0 +1,5 @@
+import { useBuConfig } from './useBuConfig';
+
+const useBuComponent = (path) => useBuConfig(path, 'default', 'vue');
+
+export default useBuComponent;

package/cdp-due--customer-space-module-master/src/composables/useBuConfig.js

@@ -0,0 +1,34 @@
+import { ref } from 'vue';
+
+import { config } from '@/config';
+import { BU_CODES } from '@/utils/getFromBuCode';
+import { logger } from '@/utils/logger';
+
+async function getContent(path, item, ext, buCode) {
+	return (
+		await import(
+			/* webpackMode: 'eager' */
+			`../${path}.${buCode}.${ext}`
+		)
+	)[item];
+}
+
+export function useBuConfig(path, item = 'default', ext = 'js') {
+	const content = ref();
+
+	function getContentSuccess(result) {
+		content.value = result;
+	}
+
+	getContent(path, item, ext, config.BU_CODE)
+		.then(getContentSuccess)
+		.catch(() => {
+			getContent(path, item, ext, BU_CODES.DEFAULT)
+				.then(getContentSuccess)
+				.catch(() => {
+					logger.error('Component not found for ', path, item, ext);
+				});
+		});
+
+	return content;
+}

package/cdp-due--customer-space-module-master/src/composables/useCitiesOptions.js

@@ -0,0 +1,33 @@
+import { computed } from 'vue';
+
+import { CITIES_OPTIONS_LOADER } from '@/components/loading/loaders';
+import useLoading from '@/components/loading/useLoading';
+import { config } from '@/config';
+import { fetchCitiesOptions, setCitiesOptions } from '@/contents/admin/module/actions';
+import { getCitiesOptions } from '@/contents/admin/module/getters';
+import { tc } from '@/i18n';
+
+const { ENABLE_FETCH_CITIES } = config;
+
+const useCitiesOptions = () => {
+	const citiesOptions = computed(() => getCitiesOptions());
+	const loading = useLoading(CITIES_OPTIONS_LOADER);
+
+	const fetchCitiesByZipCode = (zipCode) => {
+		if (zipCode) {
+			if (!loading.value && ENABLE_FETCH_CITIES) {
+				fetchCitiesOptions(zipCode);
+			}
+		} else {
+			setCitiesOptions([]);
+		}
+	};
+
+	return {
+		citiesOptions,
+		fetchCitiesByZipCode,
+		loader: CITIES_OPTIONS_LOADER,
+	};
+};
+
+export default useCitiesOptions;

package/cdp-due--customer-space-module-master/src/composables/useCountry.js

@@ -0,0 +1,70 @@
+import { computed, watch } from 'vue';
+
+import useLoading from '@/components/loading/useLoading';
+import { config } from '@/config';
+import { COUNTRY_CODES } from '@/constants';
+import { setProFieldsByCountry } from '@/domains/administrative-identifier/administrativeIdentifier.rules';
+import { fetchCountries } from '@/module/general/actions';
+import { FETCH_COUNTRIES_LOADER } from '@/module/general/constants';
+import { getCountries } from '@/module/general/getters';
+import { BU_CODES, getFromBuCode } from '@/utils/getFromBuCode';
+
+const formatCountries = (countries) =>
+	countries ? Object.entries(countries).map(([text, value]) => ({ value, text })) : null;
+
+const useCountry = () => {
+	const countries = computed(() => getCountries());
+	const isLoading = useLoading(FETCH_COUNTRIES_LOADER);
+
+	// countriesOptions ne sert que pour les sélecteurs des formulaires
+	const countriesOptions = computed(() => formatCountries(countries.value) ?? []);
+	const defaultCountryCode = COUNTRY_CODES[config.BU_CODE];
+
+	watch(
+		countries,
+		(newCountries) => {
+			if (!newCountries && !isLoading.value) {
+				fetchCountries();
+			}
+		},
+		{ immediate: true },
+	);
+
+	function initCountry(country, setFormValue) {
+		watch(
+			[countriesOptions, country],
+			([newCountriesOptions, newCountry]) => {
+				if (newCountriesOptions.length && !newCountry) {
+					// Si la liste des pays est disponible
+					// et qu'il n'y a pas de valeur dans le formulaire
+					// alors on set une valeur par défaut liée à la BU
+					setFormValue('country', defaultCountryCode);
+				}
+			},
+			{
+				immediate: true,
+			},
+		);
+	}
+
+	function watchCountry(country, setFormValue, customerInfo) {
+		watch([country, customerInfo], ([newCountry, newCustomerInfo]) => {
+			getFromBuCode({
+				[BU_CODES.FRLM]: newCustomerInfo.isCustomerPro
+					? setProFieldsByCountry(setFormValue, newCountry, !!country)
+					: null,
+				[BU_CODES.DEFAULT]: null,
+			});
+		});
+	}
+
+	return {
+		countries,
+		countriesOptions,
+		defaultCountryCode,
+		initCountry,
+		watchCountry,
+	};
+};
+
+export default useCountry;

package/cdp-due--customer-space-module-master/src/composables/useCustomDiscounts.js

@@ -0,0 +1,63 @@
+import { computed, ref } from 'vue';
+
+import useDiscounts from '@/composables/useDiscounts.js';
+import { customRewardsRules } from '@/contents/discounts/custom-discount-section/rules.js';
+import { setShowAvailableDiscounts } from '@/contents/discounts/module/actions';
+import { getShowAvailableDiscounts } from '@/contents/discounts/module/getters';
+
+export function useCustomDiscounts() {
+	const { customDiscounts } = useDiscounts();
+	const showAvailableDiscounts = computed(() => getShowAvailableDiscounts());
+
+	const outdatedCustomDiscounts = computed(() =>
+		customRewardsRules.getOutdatedCustomDiscounts(customDiscounts.value),
+	);
+
+	const activeCustomDiscounts = computed(() =>
+		customRewardsRules.getActiveCustomDiscounts(customDiscounts.value),
+	);
+
+	const shouldDisplayDiscounts = computed(() =>
+		customRewardsRules.shouldDisplayDiscounts(activeCustomDiscounts.value),
+	);
+
+	const shouldDisplayOutdatedDiscounts = computed(() =>
+		customRewardsRules.shouldDisplayDiscounts(outdatedCustomDiscounts.value),
+	);
+
+	const switchBetweenValidAndInvalid = (status) => {
+		setShowAvailableDiscounts(status);
+	};
+
+	const DISPLAY_ALL_LIMIT = 3;
+	const showMoreRewards = ref(false);
+
+	const discounts = computed(() => {
+		const fullCollection = activeCustomDiscounts.value || [];
+		if (showMoreRewards.value) {
+			return fullCollection;
+		} else {
+			return fullCollection.slice(0, DISPLAY_ALL_LIMIT);
+		}
+	});
+
+	const shouldDisplayMoreButton = computed(
+		() => activeCustomDiscounts.value?.length > DISPLAY_ALL_LIMIT,
+	);
+
+	function toggleMoreState() {
+		showMoreRewards.value = !showMoreRewards.value;
+	}
+
+	return {
+		showAvailableDiscounts,
+		activeCustomDiscounts,
+		outdatedCustomDiscounts,
+		shouldDisplayDiscounts,
+		shouldDisplayOutdatedDiscounts,
+		switchBetweenValidAndInvalid,
+		discounts,
+		shouldDisplayMoreButton,
+		toggleMoreState,
+	};
+}

package/cdp-due--customer-space-module-master/src/composables/useCustomerConsents.js

@@ -0,0 +1,129 @@
+import { computed, watchEffect } from 'vue';
+
+import {
+	AVAILABLE_CONSENTS_LOADER,
+	CUSTOMER_CONSENTS_LOADER,
+	CUSTOMER_DIGITAL_CONSENTS_LOADER,
+	OFFLINE_CONSENTS_LOADER,
+	TEMP_CUSTOMER_CONSENTS_LOADER,
+} from '@/components/loading/loaders';
+import useLoading from '@/components/loading/useLoading';
+import {
+	fetchAvailableConsents,
+	fetchCustomerConsents,
+	fetchCustomerDigitalConsents,
+	fetchOfflineCustomerConsents,
+	fetchTempCustomerConsents,
+} from '@/contents/communications/module/actions';
+import {
+	getAvailableConsents,
+	getCustomerConsents,
+	getCustomerDigitalConsents,
+	getOfflineConsents,
+	getTempCustomerConsents,
+} from '@/contents/communications/module/getters';
+
+export const CUSTOMER_CONSENTS_FETCHING_TYPES = {
+	OFFLINE: 'offline',
+	PUBLIC: 'public',
+	CONNECTED: 'connected',
+	DIGITAL: 'digital',
+	DIGITAL_DOCUMENTS: 'DIGITAL_DOCUMENTS',
+};
+
+const consentsMethodMapping = {
+	[CUSTOMER_CONSENTS_FETCHING_TYPES.OFFLINE]: getOfflineConsents,
+};
+
+function getConsentsMethod(type) {
+	const method = consentsMethodMapping[type];
+	return method ?? getCustomerConsents;
+}
+
+// maybe split or try to find another way to do this
+// TODO : calls share the same loader, but they are not the same, this is non sense
+// grouping all in one implies either to control the fetching or accepting having irrelevant calls being performed
+export const useCustomerConsents = ({ type, data }) => {
+	const customerConsents = computed(() => getConsentsMethod(type)());
+
+	const loading = useLoading(CUSTOMER_CONSENTS_LOADER);
+	watchEffect(() => {
+		if (!loading.value && !customerConsents.value) {
+			if (type === CUSTOMER_CONSENTS_FETCHING_TYPES.OFFLINE) {
+				fetchOfflineCustomerConsents(data.token);
+			} else if (type === CUSTOMER_CONSENTS_FETCHING_TYPES.CONNECTED) {
+				fetchCustomerConsents();
+			} else if (type === CUSTOMER_CONSENTS_FETCHING_TYPES.PUBLIC) {
+				fetchAvailableConsents();
+			}
+		}
+	});
+
+	return { customerConsents };
+};
+
+export function useTempCustomerConsents({ type, data, communicationType }) {
+	const customerConsents = computed(() => getTempCustomerConsents());
+	const loading = useLoading(TEMP_CUSTOMER_CONSENTS_LOADER);
+
+	const tempCustomerConsents = computed(() => {
+		if (communicationType) {
+			return customerConsents.value?.filter(
+				({ type: itemType }) => itemType === communicationType,
+			);
+		}
+		return customerConsents.value;
+	});
+
+	watchEffect(() => {
+		if (type === CUSTOMER_CONSENTS_FETCHING_TYPES.OFFLINE) {
+			fetchOfflineCustomerConsents(data.token);
+		} else if (!loading.value && !tempCustomerConsents.value) {
+			fetchTempCustomerConsents();
+		}
+	});
+	return { tempCustomerConsents };
+}
+
+export function useAvailableConsents(type) {
+	const availableConsents = computed(() => {
+		const consents = getAvailableConsents();
+
+		if (type) {
+			return consents?.filter(({ type: itemType }) => itemType === type);
+		}
+		return consents;
+	});
+
+	const loading = useLoading(AVAILABLE_CONSENTS_LOADER);
+
+	watchEffect(() => {
+		if (!loading.value && !availableConsents.value) {
+			fetchAvailableConsents(type);
+		}
+	});
+	return { availableConsents };
+}
+
+export function useOfflineConsents(token) {
+	const offlineConsents = computed(() => getOfflineConsents());
+	const loading = useLoading(OFFLINE_CONSENTS_LOADER);
+
+	watchEffect(() => {
+		if (!loading.value && !offlineConsents.value) {
+			fetchOfflineCustomerConsents(token);
+		}
+	});
+	return { offlineConsents };
+}
+
+export const useDigitalCustomerConsents = () => {
+	const customerDigitalConsents = computed(() => getCustomerDigitalConsents());
+	const loading = useLoading(CUSTOMER_DIGITAL_CONSENTS_LOADER);
+	watchEffect(() => {
+		if (!loading.value && !customerDigitalConsents.value) {
+			fetchCustomerDigitalConsents();
+		}
+	});
+	return customerDigitalConsents;
+};

package/cdp-due--customer-space-module-master/src/composables/useCustomerInfo.js

@@ -0,0 +1,146 @@
+import { computed, watch } from 'vue';
+import { useMutation } from '@tanstack/vue-query';
+
+import { NO_USER } from '@/authentication/module/constants';
+import {
+	useIsAnyCustomer,
+	useIsCollaborator,
+	useIsCustomerParticular,
+	useIsCustomerPro,
+} from '@/authentication/useRole';
+import { addNotification } from '@/components/ipn-notification-toast/module/actions';
+import { CUSTOMER_ADDRESSES_LOADER, CUSTOMER_INFO_LOADER } from '@/components/loading/loaders';
+import useLoading from '@/components/loading/useLoading';
+import useUserInfo from '@/composables/useUserInfo';
+import { ACTIVE, NO_ACCOUNT, PRE_CREATION } from '@/constants/accountStatus';
+import { EMPLOYEE_FUNDING_ID, EMPLOYEE_ID } from '@/constants/loyaltyType';
+import { updateCustomerInfoMutation } from '@/contents/personal-data/personal-data-account/personalDataAccount.requests';
+import { tc } from '@/i18n';
+import { fetchCustomerAddresses, fetchCustomerInfo } from '@/module/actions';
+import { getStoresList } from '@/module/general/getters';
+import { getCustomerAddresses, getCustomerInfo } from '@/module/getters';
+import { dispatchUserInfos } from '@/utils/dispatchUserInfos';
+import { syncUserNameOnStaticContent } from '@/utils/syncUserNameOnStaticContent';
+
+export function useCustomerInfo() {
+	const customerInfo = computed(() => getCustomerInfo());
+	const customerAddresses = computed(() => getCustomerAddresses());
+	const customerInfoLoading = useLoading(CUSTOMER_INFO_LOADER);
+	const customerAddressesLoading = useLoading(CUSTOMER_ADDRESSES_LOADER);
+
+	const hasAddress = computed(
+		() => Array.isArray(customerAddresses.value) && customerAddresses.value.length > 0,
+	);
+
+	const userInfo = useUserInfo();
+
+	watch(
+		userInfo,
+		(newUserInfo) => {
+			if (newUserInfo && newUserInfo !== NO_USER) {
+				if (!customerInfo.value && !customerInfoLoading.value) {
+					fetchCustomerInfo();
+				}
+				if (!customerAddresses.value && !customerAddressesLoading.value) {
+					fetchCustomerAddresses();
+				}
+			}
+		},
+		{ immediate: true },
+	);
+
+	watch(
+		customerInfo,
+		(newCustomerInfo) => {
+			if (newCustomerInfo) {
+				/* since there are other execution contexts (header, menu) displaying the user name
+				we need to sync the user name on those contexts as well
+				*/
+				syncUserNameOnStaticContent(newCustomerInfo);
+				dispatchUserInfos(newCustomerInfo);
+			}
+		},
+		{ immediate: true },
+	);
+
+	const socialNetworkProfile = computed(() => customerInfo.value?.socialNetworkProfile);
+
+	// User roles
+	const isCollaborator = useIsCollaborator();
+	const isAnyCustomer = useIsAnyCustomer();
+	const isCustomerPro = useIsCustomerPro();
+	const isCustomerParticular = useIsCustomerParticular();
+	// Customer conditions
+	const isEmployee = computed(() => {
+		const employeePrograms = [EMPLOYEE_ID, EMPLOYEE_FUNDING_ID];
+		// TODO: Dans le fichier de constante @/constants/loyaltyType rempalcer par des string et non des nombres
+		return employeePrograms.find((id) => customerInfo.value?.loyalty?.type?.id === String(id));
+	});
+
+	/**
+	 * * User contact details
+	 */
+	const avatar = computed(() => socialNetworkProfile.value?.avatar);
+	const mainAddress = computed(() => customerAddresses.value?.find(({ main }) => main));
+	const mainPhone = computed(() => customerInfo.value?.phones?.find(({ main }) => main));
+	const email = computed(() => customerInfo.value?.email);
+
+	const hasCompany = computed(() => customerInfo.value?.type === 'COMPANY');
+
+	const hasWebAccount = computed(() => customerInfo.value?.webUser.status === ACTIVE);
+	const hasPreCreateWebAccount = computed(
+		() => customerInfo.value?.webUser.status === PRE_CREATION,
+	);
+	const hasNoWebAccount = computed(() => customerInfo.value?.webUser.status === NO_ACCOUNT);
+
+	const customerId = computed(() => customerInfo.value?.id);
+
+	const { status, ...customerInfoMutation } = useMutation({
+		mutationFn: updateCustomerInfoMutation,
+	});
+
+	async function updateCustomer(customerInfos) {
+		await customerInfoMutation.mutateAsync(customerInfos);
+		fetchCustomerInfo();
+	}
+
+	async function updateCustomerStore(customerInfos) {
+		await customerInfoMutation.mutateAsync(customerInfos);
+		const stores = getStoresList();
+		const store = customerInfos.declaredStoreAttachement;
+		const storeFound = stores?.find(({ id }) => id == store);
+		addNotification({
+			text: tc('customer-space_personal-data_account-store_notification') + storeFound.label,
+		});
+		fetchCustomerInfo();
+	}
+
+	const hasCommunityProfile = computed(
+		() => socialNetworkProfile.value && socialNetworkProfile.value?.id !== 'null',
+	);
+
+	return {
+		avatar,
+		isAnyCustomer,
+		isCustomerPro,
+		isCustomerParticular,
+		isCollaborator,
+		isEmployee,
+		mainAddress,
+		mainPhone,
+		email,
+		socialNetworkProfile,
+		customerInfo,
+		customerAddresses,
+		hasCompany,
+		hasWebAccount,
+		hasPreCreateWebAccount,
+		hasNoWebAccount,
+		status,
+		updateCustomer,
+		updateCustomerStore,
+		customerId,
+		hasAddress,
+		hasCommunityProfile,
+	};
+}

package/cdp-due--customer-space-module-master/src/composables/useCustomerLoyalty.js

@@ -0,0 +1,85 @@
+import { computed } from 'vue';
+
+import { useCustomerInfo } from '@/composables/useCustomerInfo';
+import { HOUSING_PASS_ID, LEROY_AND_ME_ID } from '@/constants/loyaltyType';
+import { LOYALTY_ADHESION_ROUTE, LOYALTY_ROUTE } from '@/contents/loyalty/routes';
+import { useGetAvailablePrograms } from '@/domains/loyalty/available-programs/getAvailablePrograms.composable';
+import { formatter } from '@/utils/formatter';
+
+export default function useCustomerLoyalty() {
+	const { customerInfo } = useCustomerInfo();
+
+	const loyalty = computed(() => customerInfo.value?.loyalty);
+	const { loyaltyPrograms } = useGetAvailablePrograms();
+	const barcodeSrc = computed(() => `data:image/png;base64,${loyalty.value.barcode}`);
+
+	const isPassMaison = computed(() => loyalty.value?.type?.id == HOUSING_PASS_ID);
+
+	const isAdherable = computed(() => {
+		if (!loyalty.value) {
+			return true;
+		}
+		return (
+			!loyalty.value.hasLoyalty ||
+			loyalty.value.remembershipAvailable ||
+			loyalty.value.type.id == HOUSING_PASS_ID ||
+			parseInt(loyalty.value.type.id, 10) === LEROY_AND_ME_ID
+		);
+	});
+
+	const goToLoyaltyPage = () => {
+		const routePath = isAdherable.value ? LOYALTY_ADHESION_ROUTE : LOYALTY_ROUTE;
+		// Force le passage par le Nginx
+		document.location.href = routePath;
+	};
+
+	const hasLoyaltyExpired = computed(() => loyalty.value?.expired);
+	const hasLoyalty = computed(() => loyalty.value?.hasLoyalty);
+	const expirationDate = computed(() =>
+		loyalty.value?.endDate ? formatter(loyalty.value?.endDate, 'date') : '',
+	);
+	const adhesionDate = computed(() =>
+		loyalty.value?.startDate ? formatter(loyalty.value?.startDate, 'date') : '',
+	);
+	const reEnrollDate = computed(() => {
+		const date = new Date(loyalty.value?.reEnroll?.endDate);
+		const limitDate = formatter(date, 'date');
+		return limitDate;
+	});
+
+	const readhesionDate = computed(() => loyalty.value?.reEnroll?.endDate);
+	const remembershipAvailable = computed(() => loyalty.value?.remembershipAvailable);
+
+	const canSubscribeAgain = computed(
+		() => remembershipAvailable.value && loyaltyPrograms.value?.programs.length,
+	);
+
+	const percent = computed(() => (1000 - loyalty.value?.missingPoints) / 10);
+
+	const loyaltyLabel = computed(() => loyalty.value?.type.label);
+
+	const points = computed(() => loyalty.value?.points);
+	const pointTransformationAvailable = computed(
+		() => loyalty.value?.pointTransformationAvailable,
+	);
+
+	return {
+		barcodeSrc,
+		loyalty,
+		isPassMaison,
+		isAdherable,
+		percent,
+		expirationDate,
+		adhesionDate,
+		readhesionDate,
+		hasLoyaltyExpired,
+		reEnrollDate,
+		remembershipAvailable,
+		goToLoyaltyPage,
+		loyaltyLabel,
+		canShow: canSubscribeAgain,
+		hasLoyalty,
+		points,
+		pointTransformationAvailable,
+	};
+}