create-du-app 0.1.3 → 0.1.5

package/templates/mobile/rn/src/core/utils/date.util.ts

@@ -0,0 +1,97 @@
+export const formatDateFr = (dateString?: string | null): string => {
+    if (!dateString) return '--';
+
+    const date = new Date(dateString);
+    if (Number.isNaN(date.getTime())) return '--';
+
+    return date.toLocaleDateString('fr-FR', {
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric',
+    });
+};
+
+export const isPastDate = (date: Date): boolean => {
+    const now = new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const target = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    return target.getTime() < today.getTime();
+};
+
+const parisOffsetMs = (utcDate: Date): number => {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: 'Europe/Paris',
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit',
+        hour12: false,
+    }).formatToParts(utcDate).reduce<Record<string, string>>((acc, p) => {
+        if (p.type !== 'literal') acc[p.type] = p.value;
+        return acc;
+    }, {});
+    const parisAsUtc = Date.UTC(
+        Number(parts.year),
+        Number(parts.month) - 1,
+        Number(parts.day),
+        Number(parts.hour === '24' ? '00' : parts.hour),
+        Number(parts.minute),
+        Number(parts.second),
+    );
+    return parisAsUtc - utcDate.getTime();
+};
+
+// Extract "HH:mm" verbatim from a BE timestamp without any timezone conversion.
+// BE stores visit-slot times as wall-clock HH:mm even when the marker says +00:00,
+// so reading the digits directly is what keeps Select/Update screens in sync.
+// Accepts "YYYY-MM-DDTHH:mm:ss(.SSS)?(Z|±HH:MM)?" or "YYYY-MM-DD HH:mm:ss".
+export const extractRawHHMM = (input?: string | null): string | null => {
+    if (!input) return null
+    const match = input.match(/T(\d{2}:\d{2})|[ ](\d{2}:\d{2})/)
+    if (!match) return null
+    return match[1] ?? match[2] ?? null
+}
+
+// Inverse of parisLocalToUtcIso: extract "HH:mm" in Paris time from any parseable date string.
+// Returns null when the input cannot be parsed (covers undefined-shaped responses from older BE).
+export const extractParisHHMM = (input?: string | null): string | null => {
+    if (!input) return null
+    const date = new Date(input)
+    if (Number.isNaN(date.getTime())) return null
+    const parts = new Intl.DateTimeFormat('en-GB', {
+        timeZone: 'Europe/Paris',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).formatToParts(date).reduce<Record<string, string>>((acc, p) => {
+        if (p.type !== 'literal') acc[p.type] = p.value
+        return acc
+    }, {})
+    const hh = parts.hour === '24' ? '00' : parts.hour
+    if (!hh || !parts.minute) return null
+    return `${hh}:${parts.minute}`
+}
+
+// Build UTC ISO from a Paris-local YYYY-MM-DD (taken from `date` components) + "HH:mm" string.
+// DST-aware: computes the Paris offset for the target instant, so 13:00 Paris in May
+// resolves to 11:00 UTC and in January to 12:00 UTC.
+export const parisLocalToUtcIso = (date: Date, time: string): string => {
+    const yyyy = date.getFullYear();
+    const mm = `0${date.getMonth() + 1}`.slice(-2);
+    const dd = `0${date.getDate()}`.slice(-2);
+    const [hh, min] = time.split(':');
+    const naiveUtcMs = Date.UTC(Number(yyyy), Number(mm) - 1, Number(dd), Number(hh), Number(min), 0);
+    const offset = parisOffsetMs(new Date(naiveUtcMs));
+    return new Date(naiveUtcMs - offset).toISOString();
+};
+
+export const formatDateFrLong = (dateString?: string | null): string => {
+    if (!dateString) return '--';
+
+    const date = new Date(dateString);
+    if (Number.isNaN(date.getTime())) return '--';
+
+    return date.toLocaleDateString('fr-FR', {
+        day: 'numeric',
+        month: 'long',
+        year: 'numeric',
+    });
+};

package/templates/mobile/rn/src/core/utils/device-locale.util.ts

@@ -0,0 +1,22 @@
+import { findBestLanguageTag } from 'react-native-localize';
+
+/** Languages the app ships translations for. */
+export type AppLanguage = 'fr' | 'en';
+
+/** Supported app languages, in preference order, for best-match resolution. */
+const SUPPORTED: AppLanguage[] = ['fr', 'en'];
+
+/**
+ * The device's language collapsed to a supported app language: French when the
+ * phone's preferred languages best-match French, English otherwise (the default
+ * for every other locale) — LIFEMASTER-369.
+ *
+ * Uses react-native-localize rather than the JS `Intl` API: this app's Hermes is
+ * built from source with the Intl locale data stripped, so `Intl` reports
+ * `en-US` regardless of the device — the native module reads the real OS
+ * preferred-languages list instead.
+ */
+export const deviceAppLanguage = (): AppLanguage => {
+  const best = findBestLanguageTag(SUPPORTED);
+  return best?.languageTag === 'fr' ? 'fr' : 'en';
+};

package/templates/mobile/rn/src/core/utils/emitter/index.ts

@@ -0,0 +1,161 @@
+import { useCallback, useRef, useEffect } from 'react';
+import { useFocusEffect } from '@react-navigation/native';
+
+import { EventKeyName, EventParamsList, Listeners } from './type';
+
+export { EVENT_NAME } from './type';
+export type { EventKeyName } from './type';
+
+// ─── internal state ──────────────────────────────────────────────────────────
+
+const listeners: Listeners = [];
+
+/** Mỗi eventKey chỉ giữ đúng 1 pending payload */
+const pendingQueue = new Map<string, unknown>();
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function randomUniqueId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        // eslint-disable-next-line no-bitwise
+        const r = (Math.random() * 16) | 0;
+        // eslint-disable-next-line no-bitwise
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+
+function hasConsumer(eventKey: string): boolean {
+    return listeners.some((l) => l.eventKey === eventKey);
+}
+
+// ─── subscribeEvent (hàm gốc, không thay đổi) ────────────────────────────────
+
+export const subscribeEvent = <P, T extends string = string>(
+    ...args: T extends EventKeyName
+        ? [
+            eventKey: T,
+            listener: undefined extends EventParamsList[T]
+            ? () => void
+            : (data: EventParamsList[T]) => void,
+        ]
+        : [eventKey: T, listener: (data: P) => void]
+) => {
+    const uuid = randomUniqueId();
+
+    listeners.push({
+        eventKey: args[0],
+        listener: args[1],
+        uuid,
+    });
+
+    return () => {
+        const index = listeners.findIndex((x) => x.uuid === uuid);
+        listeners.splice(index, 1);
+    };
+};
+
+// ─── internal emit helper ────────────────────────────────────────────────────
+
+function dispatchToListeners(eventKey: string, payload: unknown) {
+    for (const element of listeners) {
+        if (element.eventKey === eventKey) {
+            element.listener(payload);
+        }
+    }
+}
+
+// ─── emitEvent – emit thẳng, không queue (giữ nguyên luồng cũ) ───────────────
+
+export const emitEvent = <P, T extends string = string>(
+    ...args: T extends EventKeyName
+        ? undefined extends EventParamsList[T]
+        ? [eventName: T]
+        : [eventName: T, payload: P | EventParamsList[T]]
+        : [eventName: T, payload?: P]
+) => {
+    // Dùng as tuple để tránh lỗi "length 1 has no element at index 1"
+    const eventKey = args[0];
+    const payload = (args as [string, unknown?])[1];
+    dispatchToListeners(eventKey, payload);
+};
+
+// ─── emitPendingEvent – emit hoặc đưa vào queue ──────────────────────────────
+/**
+ * - Có consumer đang lắng nghe → emit thẳng, clear pending cũ nếu có.
+ * - Không có consumer → ghi vào pendingQueue (1 slot/key, replace nếu emit lại).
+ * - Chỉ `useSubscribeEvent` mới tự drain pending khi focus/mount.
+ */
+export const emitPendingEvent = <P, T extends string = string>(
+    ...args: T extends EventKeyName
+        ? undefined extends EventParamsList[T]
+        ? [eventName: T]
+        : [eventName: T, payload: P | EventParamsList[T]]
+        : [eventName: T, payload?: P]
+) => {
+    const eventKey = args[0];
+    const payload = (args as [string, unknown?])[1];
+
+    if (hasConsumer(eventKey)) {
+        pendingQueue.delete(eventKey);
+        dispatchToListeners(eventKey, payload);
+    } else {
+        pendingQueue.set(eventKey, payload);
+    }
+};
+
+// ─── useSubscribeEvent ────────────────────────────────────────────────────────
+/**
+ * Hook subscribe event + tự drain pending khi màn hình được focus (mount).
+ *
+ * Behavior:
+ * 1. Subscribe listener như bình thường (nhận emit real-time).
+ * 2. Khi useFocusEffect trigger → kiểm tra pendingQueue:
+ *    - Nếu có pending cho eventKey này → gọi listener 1 lần rồi xóa khỏi queue.
+ * 3. Unsubscribe khi unmount / blur (tùy cleanup của useFocusEffect).
+ */
+export const useSubscribeEvent = <P, T extends string = string>(
+    ...args: T extends EventKeyName
+        ? [
+            eventKey: T,
+            listener: undefined extends EventParamsList[T]
+            ? () => void
+            : (data: EventParamsList[T]) => void,
+        ]
+        : [eventKey: T, listener: (data: P) => void]
+) => {
+    const [eventKey, listener] = args;
+    const listenerRef = useRef(listener);
+
+    // Update ref whenever listener changes to capture latest value
+    useEffect(() => {
+        listenerRef.current = listener;
+    }, [listener]);
+
+    useFocusEffect(
+        useCallback(() => {
+            // 1. Đăng ký listener via ref wrapper để tránh stale closure
+            const uuid = randomUniqueId();
+            const handler = (data: any) => (listenerRef.current as any)(data);
+            listeners.push({ eventKey, listener: handler, uuid });
+
+            // 2. Drain pending nếu có (chỉ 1 lần, xóa ngay)
+            if (pendingQueue.has(eventKey)) {
+                const pendingPayload = pendingQueue.get(eventKey);
+                pendingQueue.delete(eventKey);
+                dispatchToListeners(eventKey, pendingPayload);
+            }
+
+            // 3. Cleanup khi blur / unmount
+            return () => {
+                const index = listeners.findIndex((x) => x.uuid === uuid);
+                if (index !== -1) listeners.splice(index, 1);
+            };
+        }, [eventKey]),
+    );
+};
+
+export const unSubscribeAllEvent = () => {
+    listeners.length = 0;
+    pendingQueue.clear();
+};

package/templates/mobile/rn/src/core/utils/emitter/type.ts

@@ -0,0 +1,40 @@
+type FilterValues = Record<string, unknown>;
+type CoachResultPayload = Record<string, unknown>;
+
+export const EVENT_NAME = {
+    APPLY_FILTER: 'APPLY_FILTER',
+    READ_NOTIFICATION_ALL: 'READ_NOTIFICATION_ALL',
+    READ_NOTIFICATION_BY_ID: 'READ_NOTIFICATION_BY_ID',
+    ADDRESS_SELECTED: 'ADDRESS_SELECTED',
+    IMONI_COACH_RESULT_ACCEPTED: 'IMONI_COACH_RESULT_ACCEPTED',
+    RELOAD_RECOMMENDATIONS: 'RELOAD_RECOMMENDATIONS',
+} as const;
+
+export interface EventParamsList {
+    [EVENT_NAME.APPLY_FILTER]: {
+        values: FilterValues;
+        params: any; // You can replace 'any' with the actual type of params if you have it defined
+    };
+    [EVENT_NAME.READ_NOTIFICATION_ALL]: undefined;
+    [EVENT_NAME.RELOAD_RECOMMENDATIONS]: undefined;
+    [EVENT_NAME.ADDRESS_SELECTED]: AddressSelectedResult;
+    [EVENT_NAME.IMONI_COACH_RESULT_ACCEPTED]: {
+        contextKey: string;
+        screen: string;
+        coachPayload: CoachResultPayload;
+    };
+    [key: string]: any; // This allows for dynamic event keys like 'READ_NOTIFICATION_BY_ID_123'
+}
+
+export type EventKeyName = keyof EventParamsList;
+
+export type ListenerCallback<P, T> = T extends EventKeyName
+    ? (data: EventParamsList[T]) => void
+    : (data: P) => void;
+
+export type Listeners = Array<{
+    uuid: string;
+    eventKey: string;
+
+    listener: any;
+}>;

package/templates/mobile/rn/src/core/utils/enum.util.tsx

@@ -0,0 +1,15 @@
+/**
+ * Shared domain enums.
+ *
+ * The canonical definitions now live in `@repo/shared` so every app
+ * (mobile / backend / admin / frontend) shares one source of truth.
+ * Re-exported here to keep existing `@src/core/utils` imports working.
+ */
+export {
+  UserRole,
+  UserType,
+  VerifyCodeType,
+  InteractiveMapType,
+  PropertyType,
+  FeeMode,
+} from '@repo/shared';

package/templates/mobile/rn/src/core/utils/font.util.tsx

@@ -0,0 +1,42 @@
+/**
+ * Font families (Life-Master-Design — DM Sans).
+ *
+ * Values are the PostScript names of the bundled DM Sans .ttf files
+ * (src/assets/fonts/DMSans-*.ttf). Use the `dmSans*` keys in new code.
+ *
+ * The legacy `rethinkSans*` keys are kept as deprecated aliases that now point
+ * at DM Sans so the ~93 existing files keep compiling and render DM Sans.
+ */
+export const Font = {
+  // --- DM Sans (design system) ---
+  dmSansRegular: 'DMSans-Regular',
+  dmSansMedium: 'DMSans-Medium',
+  dmSansSemiBold: 'DMSans-SemiBold',
+  dmSansBold: 'DMSans-Bold',
+  dmSansExtraBold: 'DMSans-ExtraBold',
+  dmSansItalic: 'DMSans-Italic',
+  dmSansMediumItalic: 'DMSans-MediumItalic',
+  dmSansSemiBoldItalic: 'DMSans-SemiBoldItalic',
+  dmSansBoldItalic: 'DMSans-BoldItalic',
+
+  /** @deprecated RethinkSans was removed — now maps to DM Sans. Use {@link Font.dmSansRegular}. */
+  rethinkSansRegular: 'DMSans-Regular',
+  /** @deprecated use {@link Font.dmSansBold} */
+  rethinkSansBold: 'DMSans-Bold',
+  /** @deprecated use {@link Font.dmSansExtraBold} */
+  rethinkSansExtraBold: 'DMSans-ExtraBold',
+  /** @deprecated use {@link Font.dmSansBoldItalic} */
+  rethinkSansBoldItalic: 'DMSans-BoldItalic',
+  /** @deprecated use {@link Font.dmSansExtraBold} */
+  rethinkSansExtraBoldItalic: 'DMSans-ExtraBold',
+  /** @deprecated use {@link Font.dmSansItalic} */
+  rethinkSansItalic: 'DMSans-Italic',
+  /** @deprecated use {@link Font.dmSansMedium} */
+  rethinkSansMedium: 'DMSans-Medium',
+  /** @deprecated use {@link Font.dmSansMediumItalic} */
+  rethinkSansMediumItalic: 'DMSans-MediumItalic',
+  /** @deprecated use {@link Font.dmSansSemiBold} */
+  rethinkSansSemiBold: 'DMSans-SemiBold',
+  /** @deprecated use {@link Font.dmSansSemiBoldItalic} */
+  rethinkSansSemiBoldItalic: 'DMSans-SemiBoldItalic',
+};

package/templates/mobile/rn/src/core/utils/func.util.ts

@@ -0,0 +1,48 @@
+import { useCommonStore } from "@src/app";
+
+function capitalizeFirstLetter(val: string) {
+    return String(val).charAt(0).toUpperCase() + String(val).slice(1)
+}
+
+function getIsNoFace(avatar: string) {
+    return avatar.includes('common-type-icon')
+}
+
+const delay = (ms: number) => new Promise<void>(resolve => setTimeout(() => resolve(), ms))
+
+const getEnumValueWithKey = (key: string) => {
+    return useCommonStore.getState().enumValues?.find(enumValue => enumValue.key === key);
+}
+
+const toNum = (v: string | number | undefined) =>
+    v !== '' && v !== undefined ? Number(v) : undefined;
+
+const toBool = (v: string | undefined) =>
+    v === 'yes' ? true : v === 'no' ? false : undefined;
+
+const toStr = (v: string | undefined) => (v && v.trim() ? v : undefined);
+
+const getBooleanValue = (value: unknown): boolean => {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value === 1;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        return (
+            normalized === 'true' ||
+            normalized === '1' ||
+            normalized === 'yes'
+        );
+    }
+    return false;
+};
+
+export {
+    capitalizeFirstLetter,
+    getIsNoFace,
+    delay,
+    getEnumValueWithKey,
+    toNum,
+    toBool,
+    toStr,
+    getBooleanValue,
+}

package/templates/mobile/rn/src/core/utils/greeting.util.ts

@@ -0,0 +1,20 @@
+import type { TFunction } from 'i18next';
+
+/**
+ * Build the "Bonjour" greeting shown on Home and Profile.
+ *
+ * The user has no name field at sign-up (LIFEMASTER-256), so the name is only
+ * known once they fill it in Edit profile. Until then we greet without a name —
+ * "Bonjour" with no trailing comma — and switch to "Bonjour, {name}" the moment
+ * a name exists (LIFEMASTER-255).
+ *
+ * @param name  The user's first name (or display name); blank/whitespace counts
+ *              as "no name".
+ * @param t     i18next translate function bound to the `home.greeting*` keys.
+ */
+export const buildGreeting = (name: string | undefined, t: TFunction): string => {
+    const trimmed = name?.trim();
+    return trimmed
+        ? t('home.greeting', { name: trimmed })
+        : t('home.greetingNoName');
+};

package/templates/mobile/rn/src/core/utils/image-format.util.ts

@@ -0,0 +1,117 @@
+export type SupportedImageMimeType = 'image/jpeg' | 'image/png';
+
+export type ImageAsset = {
+    uri: string;
+    type?: string | null;
+    name?: string | null;
+    fileName?: string | null;
+};
+
+const SUPPORTED_MIME_TYPES = new Set<SupportedImageMimeType>([
+    'image/jpeg',
+    'image/png',
+]);
+
+const MIME_TYPE_BY_EXTENSION: Record<string, SupportedImageMimeType> = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+};
+
+const sanitizeValue = (value?: string | null): string =>
+    value?.split('?')[0]?.split('#')[0]?.trim() ?? '';
+
+const getExtension = (value?: string | null): string | undefined => {
+    const sanitized = sanitizeValue(value);
+
+    if (!sanitized) {
+        return undefined;
+    }
+
+    const lastDotIndex = sanitized.lastIndexOf('.');
+
+    if (lastDotIndex === -1 || lastDotIndex === sanitized.length - 1) {
+        return undefined;
+    }
+
+    return sanitized.slice(lastDotIndex + 1).toLowerCase();
+};
+
+export const getSupportedImageMimeType = (
+    asset: ImageAsset,
+): SupportedImageMimeType | undefined => {
+    const normalizedType = sanitizeValue(asset.type).toLowerCase();
+
+    if (
+        normalizedType &&
+        SUPPORTED_MIME_TYPES.has(normalizedType as SupportedImageMimeType)
+    ) {
+        return normalizedType as SupportedImageMimeType;
+    }
+
+    const extension =
+        getExtension(asset.name) ??
+        getExtension(asset.fileName) ??
+        getExtension(asset.uri);
+
+    if (!extension) {
+        return undefined;
+    }
+
+    return MIME_TYPE_BY_EXTENSION[extension];
+};
+
+export const isSupportedImageAsset = (asset: ImageAsset): boolean =>
+    Boolean(asset.uri && getSupportedImageMimeType(asset));
+
+const buildNormalizedFileName = (
+    asset: ImageAsset,
+    index: number,
+    mimeType: SupportedImageMimeType,
+): string => {
+    const extension = mimeType === 'image/png' ? 'png' : 'jpg';
+    const rawName = sanitizeValue(asset.name) || sanitizeValue(asset.fileName);
+
+    if (rawName) {
+        const baseName = rawName.replace(/\.[^/.]+$/, '');
+        return `${baseName}.${extension}`;
+    }
+
+    return `photo_${Date.now()}_${index}.${extension}`;
+};
+
+export const normalizeImageAsset = (
+    asset: ImageAsset,
+    index = 0,
+): { uri: string; type: SupportedImageMimeType; name: string } | null => {
+    const type = getSupportedImageMimeType(asset);
+
+    if (!asset.uri || !type) {
+        return null;
+    }
+
+    return {
+        uri: asset.uri,
+        type,
+        name: buildNormalizedFileName(asset, index, type),
+    };
+};
+
+export const filterSupportedImageAssets = (assets: ImageAsset[]) => {
+    const supported: ImageAsset[] = [];
+    const unsupported: ImageAsset[] = [];
+
+    assets.forEach(asset => {
+        if (isSupportedImageAsset(asset)) {
+            supported.push(asset);
+            return;
+        }
+
+        unsupported.push(asset);
+    });
+
+    return {
+        supported,
+        unsupported,
+    };
+};

package/templates/mobile/rn/src/core/utils/image-picker.util.ts

@@ -0,0 +1,84 @@
+import { PermissionsAndroid, Platform } from 'react-native'
+import {
+    CameraOptions,
+    ImageLibraryOptions,
+    launchCamera,
+    launchImageLibrary,
+} from 'react-native-image-picker'
+
+export class ImagePicker {
+    private static optionsDefault: CameraOptions | ImageLibraryOptions = {
+        mediaType: 'photo',
+        quality: 0.8,
+        maxHeight: 800,
+        maxWidth: 800,
+    }
+
+    public static async requestCameraPermission() {
+        if (Platform.OS === 'android') {
+            const granted = await PermissionsAndroid.request(
+                PermissionsAndroid.PERMISSIONS.CAMERA,
+                {
+                    title: 'Camera Permission',
+                    message: 'App needs access to your camera',
+                    buttonNeutral: 'Ask Me Later',
+                    buttonNegative: 'Cancel',
+                    buttonPositive: 'OK',
+                },
+            )
+            return granted === PermissionsAndroid.RESULTS.GRANTED
+        }
+        return true
+    }
+
+    public static async lauchCamera(
+        options?: CameraOptions,
+    ): Promise<IMediaFormData | undefined> {
+        const granted = await this.requestCameraPermission()
+        if (!granted) {
+            return undefined
+        }
+
+        const result = await launchCamera({
+            ...this.optionsDefault,
+            ...options,
+        })
+        if (result?.assets?.[0]) {
+            const media = {
+                name:
+                    result?.assets?.[0]?.fileName ||
+                    `img-${new Date().getTime()}`,
+                type: result?.assets?.[0]?.type || '',
+                uri: result?.assets?.[0]?.uri || '',
+            }
+            return media
+        } else {
+            return undefined
+        }
+    }
+
+    public static async launchImagesLibrary(
+        options?: ImageLibraryOptions,
+    ): Promise<IMediaFormData[]> {
+        return new Promise((resolve, reject) => {
+            launchImageLibrary({
+                ...this.optionsDefault,
+                ...options,
+            })
+                .then(({ assets, didCancel, errorCode }) => {
+                    if (didCancel || errorCode) {
+                        return reject(didCancel || errorCode)
+                    }
+                    const media = (assets || []).map(
+                        ({ fileName, uri, type }) => ({
+                            name: fileName || `img-${new Date().getTime()}`,
+                            type: type || '',
+                            uri: uri || '',
+                        }),
+                    )
+                    assets && resolve(media)
+                })
+                .catch(reject)
+        })
+    }
+}

package/templates/mobile/rn/src/core/utils/index.ts

@@ -0,0 +1,18 @@
+export * from './color.util';
+export * from './greeting.util';
+export * from './navigation.util';
+export * from './schema.util';
+export * from './size.util';
+export * from './storage.util';
+export * from './translator.util';
+export * from './validate.util';
+export * from './font.util';
+export * from './typography.util';
+export * from './image-picker.util';
+export * from './func.util';
+export * from './enum.util';
+export * from './toast.util';
+export * from './query-client.util';
+export * from './query-persister.util';
+export * from './date.util';
+export * from './linking.util';

package/templates/mobile/rn/src/core/utils/linking.util.ts

@@ -0,0 +1,16 @@
+import { Linking } from 'react-native';
+import { Translator } from './translator.util';
+import { showErrorToast } from './toast.util';
+
+export const openExternalUrl = async (url: string) => {
+    try {
+        const supported = await Linking.canOpenURL(url);
+        if (!supported) {
+            showErrorToast('', Translator.translate('common.cannotOpenUrl'));
+            return;
+        }
+        await Linking.openURL(url);
+    } catch {
+        showErrorToast('', Translator.translate('common.cannotOpenUrl'));
+    }
+};