@trii/components 2.0.66 → 2.0.69

package/dist/types/components/EventsDialog/redux/types/UpdateChannelThunk.d.ts

@@ -0,0 +1,6 @@
+import { AsyncThunk } from '@reduxjs/toolkit';
+import { RootState } from 'redux/store';
+import { IChannel } from '@trii/types/dist/Common/Channels';
+export type UpdateChannelThunk = AsyncThunk<IChannel, void, {
+    state: RootState;
+}>;

package/dist/types/components/EventsDialog/services/api.d.ts

@@ -0,0 +1,196 @@
+import { IBusiness, IContact, IContactField, IContactTag, IContactAddress } from '@trii/types/dist/Contacts/contacts';
+import { ILabel } from '@trii/types/dist/Contacts';
+import { ChannelType } from '@trii/types/dist/Common/Channels';
+import { UserTrii } from '@trii/types/dist/Users';
+import type { UserInfo } from '@trii/types/dist/Users';
+type ApiContext = {
+    baseUrl: string;
+    spaceId: string;
+};
+type WithSignal = {
+    signal?: AbortSignal;
+};
+type ApiArgs = ApiContext & WithSignal;
+export type Order = 'ASC' | 'DESC';
+export type Filter = {
+    column: string;
+    condition: string;
+    value: string;
+};
+export type TableItemFormat = 'IContact' | 'IBusiness' | 'IContactInfo';
+export type PaginationFolder = 'Main' | 'Trash' | 'MyContacts';
+export type Pagination = {
+    total: number;
+    lastPage: number;
+    currentPage: number;
+    perPage: number;
+    order: Order;
+    orderColumn: string;
+    filter: Filter[];
+    format: TableItemFormat;
+    folder?: PaginationFolder;
+};
+export type PaginationInfo = {
+    total: number;
+    lastPage: number;
+    currentPage: number;
+    perPage: number;
+    cantPageElements: number;
+};
+export type BusinessTableData = {
+    contactos: IBusiness[];
+    contactosIds: unknown[];
+    paginacion: PaginationInfo;
+};
+type FetchContactArgs = ApiArgs & {
+    contactId: string;
+};
+type FetchBusinessArgs = ApiArgs & {
+    businessId: string;
+};
+type FetchLabelsArgs = ApiArgs;
+type CreateLabelArgs = ApiArgs & {
+    name: string;
+};
+export declare function fetchLabels({ baseUrl, spaceId, signal }: FetchLabelsArgs): Promise<ILabel[]>;
+export declare function createLabel({ baseUrl, spaceId, name, signal }: CreateLabelArgs): Promise<ILabel>;
+export declare function fetchContact({ baseUrl, spaceId, contactId, signal }: FetchContactArgs): Promise<IContact | IBusiness>;
+export declare function fetchBusiness({ baseUrl, spaceId, businessId, signal }: FetchBusinessArgs): Promise<IContact | IBusiness>;
+type FetchContactFieldsArgs = ApiArgs & {
+    forType: 'contact' | 'business';
+};
+export declare function fetchContactFields({ baseUrl, spaceId, forType, signal, }: FetchContactFieldsArgs): Promise<IContactField[]>;
+type UpdateEntityArgs = ApiArgs & {
+    entityType: 'contact' | 'business';
+    entityId: string;
+    body: Partial<IContact> | Partial<IBusiness> | {
+        tags: IContactTag[];
+    };
+};
+export declare function updateEntity({ baseUrl, spaceId, entityType, entityId, body, signal, }: UpdateEntityArgs): Promise<IContact | IBusiness>;
+type FetchBusinessTableDataArgs = ApiArgs & {
+    pagination: Pagination;
+};
+export declare function fetchBusinessTableData({ baseUrl, spaceId, pagination, signal, }: FetchBusinessTableDataArgs): Promise<BusinessTableData>;
+type CreateBusinessArgs = ApiArgs & {
+    business: Record<string, unknown>;
+};
+export declare function createBusiness({ baseUrl, spaceId, business, signal }: CreateBusinessArgs): Promise<IBusiness>;
+type DeleteContactAddressData = {
+    contactId: string;
+    contactAddressId: string;
+    type: ChannelType;
+};
+type CheckContactAddressData = {
+    address: string;
+    type: ChannelType;
+};
+type ResultContactAddressCheck = {
+    success: boolean;
+    warnings: string[];
+};
+type DeleteContactAddressArgs = ApiArgs & {
+    data: DeleteContactAddressData;
+};
+type CheckContactAddressArgs = ApiArgs & {
+    data: CheckContactAddressData;
+};
+export type SetContactAddressRequestData = {
+    address: string;
+    type: ChannelType;
+    contactId: string;
+};
+export type UpdateContactAddressData = {
+    contactId: string;
+    contactAddressId: string;
+    note?: string;
+    isFavorite?: boolean;
+};
+type SetContactAddressArgs = ApiArgs & {
+    data: SetContactAddressRequestData;
+};
+type UpdateContactAddressArgs = ApiArgs & {
+    data: UpdateContactAddressData;
+};
+export declare function deleteAddress({ baseUrl, spaceId, data, signal }: DeleteContactAddressArgs): Promise<unknown>;
+export declare function checkContactAddress({ baseUrl, spaceId, data, signal, }: CheckContactAddressArgs): Promise<ResultContactAddressCheck>;
+export declare function setContactAddress({ baseUrl, spaceId, data, signal }: SetContactAddressArgs): Promise<IContactAddress>;
+export declare function updateContactAddress({ baseUrl, spaceId, data, signal, }: UpdateContactAddressArgs): Promise<IContactAddress>;
+type FetchUserTriiArgs = ApiArgs;
+export declare function fetchUserTrii({ baseUrl, spaceId, signal }: FetchUserTriiArgs): Promise<UserTrii>;
+type FetchUsersArgs = ApiArgs;
+export declare function fetchUsers({ baseUrl, spaceId, signal }: FetchUsersArgs): Promise<UserInfo[]>;
+type FetchUserTriiByIdArgs = ApiArgs & {
+    userId: string;
+};
+export declare function fetchUserTriiById({ baseUrl, spaceId, signal, userId, }: FetchUserTriiByIdArgs): Promise<UserTrii>;
+type UploadAvatarArgs = ApiArgs & {
+    contactId: string;
+    file: File;
+};
+export declare function uploadAvatar({ baseUrl, spaceId, contactId, file, signal, }: UploadAvatarArgs): Promise<string>;
+type FetchContactBoundArgs = WithSignal & {
+    contactId: string;
+};
+type FetchBusinessBoundArgs = WithSignal & {
+    businessId: string;
+};
+type FetchContactFieldsBoundArgs = WithSignal & {
+    forType: 'contact' | 'business';
+};
+type CreateLabelBoundArgs = WithSignal & {
+    name: string;
+};
+type UpdateEntityBoundArgs = WithSignal & {
+    entityType: 'contact' | 'business';
+    entityId: string;
+    body: Partial<IContact> | Partial<IBusiness> | {
+        tags: IContactTag[];
+    };
+};
+type FetchBusinessTableDataBoundArgs = WithSignal & {
+    pagination: Pagination;
+};
+type CreateBusinessBoundArgs = WithSignal & {
+    business: Record<string, unknown>;
+};
+type DeleteContactAddressBoundArgs = WithSignal & {
+    data: DeleteContactAddressData;
+};
+type CheckContactAddressBoundArgs = WithSignal & {
+    data: CheckContactAddressData;
+};
+type FetchUserTriiByIdBoundArgs = WithSignal & {
+    userId: string;
+};
+type UploadAvatarBoundArgs = WithSignal & {
+    contactId: string;
+    file: File;
+};
+type SetContactAddressBoundArgs = WithSignal & {
+    data: SetContactAddressRequestData;
+};
+type UpdateContactAddressBoundArgs = WithSignal & {
+    data: UpdateContactAddressData;
+};
+export declare const createEditContactApi: (baseUrl: string, spaceId: string) => {
+    fetchLabels: ({ signal }?: WithSignal) => Promise<ILabel[]>;
+    createLabel: ({ name, signal }: CreateLabelBoundArgs) => Promise<ILabel>;
+    fetchContact: ({ contactId, signal }: FetchContactBoundArgs) => Promise<IContact | IBusiness>;
+    fetchBusiness: ({ businessId, signal }: FetchBusinessBoundArgs) => Promise<IContact | IBusiness>;
+    fetchBusinessTableData: ({ pagination, signal }: FetchBusinessTableDataBoundArgs) => Promise<BusinessTableData>;
+    createBusiness: ({ business, signal }: CreateBusinessBoundArgs) => Promise<IBusiness>;
+    fetchContactFields: ({ forType, signal }: FetchContactFieldsBoundArgs) => Promise<IContactField[]>;
+    updateEntity: ({ entityType, entityId, body, signal }: UpdateEntityBoundArgs) => Promise<IContact | IBusiness>;
+    deleteAddress: ({ data, signal }: DeleteContactAddressBoundArgs) => Promise<unknown>;
+    deleteAddres: ({ data, signal }: DeleteContactAddressBoundArgs) => Promise<unknown>;
+    checkContactAddress: ({ data, signal }: CheckContactAddressBoundArgs) => Promise<ResultContactAddressCheck>;
+    setContactAddress: ({ data, signal }: SetContactAddressBoundArgs) => Promise<IContactAddress>;
+    updateContactAddress: ({ data, signal }: UpdateContactAddressBoundArgs) => Promise<IContactAddress>;
+    fetchUserTrii: ({ signal }?: WithSignal) => Promise<UserTrii>;
+    fetchUsers: ({ signal }?: WithSignal) => Promise<UserInfo[]>;
+    fetchUserTriiById: ({ userId, signal }: FetchUserTriiByIdBoundArgs) => Promise<UserTrii>;
+    uploadAvatar: ({ contactId, file, signal }: UploadAvatarBoundArgs) => Promise<string>;
+};
+export type EditContactApi = ReturnType<typeof createEditContactApi>;
+export {};

package/dist/types/components/EventsDialog/services/calendarApi.d.ts

@@ -0,0 +1,22 @@
+import { IEvent } from '@trii/types/dist/Calendar';
+import { ICalendar } from '@trii/types/dist/Calendar/Calendar';
+import { ITask } from '@trii/types/dist/Calendar';
+import type { AddActivityRequestData, UpdatedActivityRequestData, AddTaskRequestData, AddCalendarRequestData } from '../types';
+type ApiContext = {
+    baseUrl: string;
+    spaceId: string;
+};
+export declare function fetchActivities(ctx: ApiContext, start: string, end: string): Promise<IEvent[]>;
+export declare function addActivity(ctx: ApiContext, data: AddActivityRequestData): Promise<IEvent>;
+export declare function updateActivity(ctx: ApiContext, data: UpdatedActivityRequestData): Promise<IEvent>;
+export declare function deleteActivity(ctx: ApiContext, activityId: string, originalOccurrenceDate?: Date | string): Promise<void>;
+export declare function endActivity(ctx: ApiContext, activityId: string): Promise<IEvent>;
+export declare function fetchTasks(ctx: ApiContext, calendarId: string): Promise<ITask[]>;
+export declare function addTask(ctx: ApiContext, data: AddTaskRequestData): Promise<ITask>;
+export declare function updateTaskApi(ctx: ApiContext, taskId: string, updatedTask: Record<string, unknown>): Promise<ITask>;
+export declare function deleteTaskApi(ctx: ApiContext, taskId: string): Promise<void>;
+export declare function toggleTaskCompletedApi(ctx: ApiContext, taskId: string, isCompleted: boolean): Promise<ITask>;
+export declare function fetchCalendars(ctx: ApiContext): Promise<ICalendar[]>;
+export declare function addCalendarApi(ctx: ApiContext, data: AddCalendarRequestData): Promise<ICalendar>;
+export declare function updateCalendarApi(ctx: ApiContext, calendarId: string, data: AddCalendarRequestData): Promise<ICalendar>;
+export {};

package/dist/types/components/EventsDialog/services/http.d.ts

@@ -0,0 +1,23 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export declare class ApiError extends Error {
+    status: number;
+    body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+type RequestJsonArgs = {
+    url: string;
+    method?: HttpMethod;
+    headers?: HeadersInit;
+    body?: unknown;
+    signal?: AbortSignal;
+};
+export declare function requestJson<T>({ url, method, headers, body, signal, }: RequestJsonArgs): Promise<T>;
+type RequestFormDataArgs = {
+    url: string;
+    method?: HttpMethod;
+    headers?: HeadersInit;
+    formData: FormData;
+    signal?: AbortSignal;
+};
+export declare function requestFormData<T>({ url, method, headers, formData, signal, }: RequestFormDataArgs): Promise<T>;
+export {};

package/dist/types/components/EventsDialog/services/urls.d.ts

@@ -0,0 +1,7 @@
+export declare function joinUrl(baseUrl: string, path: string): string;
+export declare function getApiUrls(baseUrl: string, spaceId: string): {
+    CONTACTS: string;
+    MEDIA: string;
+    SETTINGS: string;
+    CALENDAR: string;
+};

package/dist/types/components/EventsDialog/types.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Modos de operación del modal
+ */
+export type ModalMode = 'create' | 'edit' | 'view';
+/**
+ * Tipos de elementos que puede manejar el modal
+ */
+export type ItemType = 'event' | 'task';
+/**
+ * Estructura de una notificación/recordatorio
+ */
+export interface Notification {
+    id?: string;
+    type: 'minutes' | 'hours' | 'days';
+    value: number;
+    sendToContact?: boolean;
+}
+/**
+ * Estructura de un calendario
+ */
+export interface Calendar {
+    id: string;
+    name?: string;
+    title?: string;
+    color?: string;
+}
+/**
+ * Estructura de un contacto
+ */
+export interface Contact {
+    id: string;
+    name: string;
+    email?: string;
+    phone?: string;
+    avatarUrl?: string;
+}
+/**
+ * Datos de un evento
+ */
+export interface EventData {
+    id?: string;
+    title: string;
+    details?: string;
+    description?: string;
+    startAt: string;
+    endAt: string;
+    allDay: boolean;
+    calendarId?: string;
+    color?: string;
+    location?: string;
+    isPrivate?: boolean;
+    rule?: string;
+    notifications?: Notification[];
+    relatedContactId?: string;
+    sharedWith?: string[];
+}
+/**
+ * Datos de una tarea
+ */
+export interface TaskData {
+    id?: string;
+    title: string;
+    description?: string;
+    startAt: string;
+    endAt: string;
+    calendarId?: string;
+    isCompleted?: boolean;
+    relatedContactId?: string;
+}
+/**
+ * Re-exportar tipos del contexto
+ */
+export type { Mode } from './context/types/Mode';
+export type { DialogType } from './context/types/DialogType';
+export type { CalendarDialogMode } from './context/types/CalendarDialogMode';
+import { IEvent, IEventNotification } from '@trii/types/dist/Calendar';
+/** Front-end notification shape (sin notificacionDateTime del backend) */
+export type EventNotificationFront = Omit<IEventNotification, 'notificacionDateTime'>;
+/** Payload para crear un evento */
+export type AddActivityRequestData = {
+    isPrivate: boolean;
+    startAt: Date;
+    endAt: Date;
+    allDay: boolean;
+    notifications: EventNotificationFront[];
+    contactId?: string | null;
+    title: string;
+    details: string;
+    location: string;
+    color?: string;
+    eventTypeId: string;
+    calendarId: string;
+    repeatId: string;
+    sharedWith: string[];
+    rule?: string;
+    originalOccurrenceDate?: Date | string;
+};
+/** Payload para actualizar un evento */
+export type UpdatedActivityRequestData = {
+    updatedActivity: Partial<IEvent>;
+    activityId: string;
+    originalOccurrenceDate?: Date | string;
+};
+/** Payload para crear una tarea */
+export type AddTaskRequestData = {
+    title: string;
+    calendarId: string;
+    startAt: string;
+    description?: string;
+    contactId?: string | null;
+};
+/** Payload para actualizar una tarea */
+export type UpdateTaskRequestData = {
+    taskId: string;
+    updatedTask: {
+        title: string;
+        description?: string;
+        startAt?: Date | string;
+        calendarId?: string;
+        contactId?: string | null;
+    };
+};
+/** Payload para crear/editar un calendario */
+export type AddCalendarRequestData = {
+    title: string;
+    color: string;
+    sharedWith?: string[];
+    googleCalendar?: any;
+};

package/dist/types/components/EventsDialog/utils/eventIdUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Utilidades para manejar IDs de eventos, especialmente eventos recurrentes
+ */
+/**
+ * Extrae el ID base de un evento, eliminando el sufijo de fecha si existe.
+ * Los eventos recurrentes pueden tener IDs con formato: {baseId}_{timestamp}
+ * Ejemplo: "69a722567f4f3905181c5bfa_20260314180200" -> "69a722567f4f3905181c5bfa"
+ *
+ * @param eventId - El ID del evento que puede contener un sufijo de timestamp
+ * @returns El ID base sin el sufijo de timestamp
+ */
+export declare const extractBaseEventId: (eventId: string) => string;
+/**
+ * Obtiene el ID correcto para usar en operaciones API de eventos.
+ * Para eventos recurrentes, usa el parentId si existe.
+ * Para eventos normales o cuando no hay parentId, extrae el ID base.
+ *
+ * @param event - El evento con posible parentId y originalOccurrenceDate
+ * @returns El ID apropiado para usar en llamadas API
+ */
+export declare const getEventIdForApi: (event: any) => string;
+/**
+ * Verifica si un evento es una ocurrencia de un evento recurrente
+ *
+ * @param event - El evento a verificar
+ * @returns true si es una ocurrencia recurrente
+ */
+export declare const isRecurringOccurrence: (event: any) => boolean;
+/**
+ * Obtiene el ID para eliminar una ocurrencia específica de un evento recurrente.
+ * Para una ocurrencia específica, usa el ID completo (con sufijo).
+ * Para eliminar todas las ocurrencias, usa getEventIdForApi.
+ *
+ * @param event - El evento a eliminar
+ * @param deleteAll - Si debe eliminar todas las ocurrencias o solo esta
+ * @returns El ID apropiado para la operación de eliminación
+ */
+export declare const getEventIdForDelete: (event: any, deleteAll?: boolean) => string;

package/dist/types/components/EventsDialog/utils/eventValidation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Utilidades para validación de eventos del calendario
+ */
+export interface CalendarItem {
+    id?: string;
+    start: Date | string;
+    end: Date | string;
+    title?: string;
+    kind?: 'event' | 'task';
+}
+/**
+ * Verifica si dos eventos se solapan en el tiempo
+ */
+export declare const eventsOverlap: (event1: CalendarItem, event2: CalendarItem) => boolean;
+/**
+ * Encuentra todos los eventos que se solapan con un evento dado
+ */
+export declare const findOverlappingEvents: (targetEvent: CalendarItem, allEvents: CalendarItem[]) => CalendarItem[];
+/**
+ * Valida que un evento tenga fechas válidas
+ */
+export declare const validateEventDates: (event: CalendarItem) => {
+    isValid: boolean;
+    error?: string;
+};
+/**
+ * Genera un mensaje descriptivo sobre eventos solapados
+ */
+export declare const getOverlapWarningMessage: (overlappingEvents: CalendarItem[]) => string;
+/**
+ * Calcula la duración de un evento en minutos
+ */
+export declare const getEventDuration: (event: CalendarItem) => number;
+/**
+ * Verifica si un evento es de todo el día
+ */
+export declare const isAllDayEvent: (event: CalendarItem) => boolean;

package/dist/types/components/EventsDialog/utils/googleMapsLoader.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Utilidad para cargar la API de Google Maps de manera asincrónica
+ * Este archivo proporciona una forma centralizada y asincrónica de cargar Google Maps
+ * para evitar problemas de rendimiento y advertencias de la consola.
+ */
+export declare const GOOGLE_MAPS_CONFIG: {
+    apiKey: string;
+    libraries: string[];
+    loading: string;
+};
+export declare const GOOGLE_MAPS_SCRIPT_CONFIG: {
+    apiKey: string;
+    libraries: string[];
+    loading: string;
+};
+/**
+ * Hook para asegurar que los scripts de Google Maps se carguen correctamente
+ * antes de inicializar componentes que dependan de ellos
+ */
+export declare const useGoogleMapsLoader: () => {
+    isLoaded: boolean;
+    error: Error | null;
+};
+/**
+ * Carga la API de Google Maps de manera asincrónica
+ * @param apiKey - La clave de API de Google Maps
+ * @param libraries - Bibliotecas opcionales para cargar (como array)
+ * @returns Una promesa que se resuelve cuando la API se ha cargado correctamente
+ */
+export declare const loadGoogleMapsAsync: (apiKey?: string, libraries?: string[] | string) => Promise<void>;
+/**
+ * Genera una URL para el mapa estático de Google Maps
+ * @param latitude - Latitud del centro del mapa
+ * @param longitude - Longitud del centro del mapa
+ * @param zoom - Nivel de zoom (1-20)
+ * @param width - Ancho de la imagen en píxeles
+ * @param height - Alto de la imagen en píxeles
+ * @param markerColor - Color del marcador (por ejemplo, "red", "blue")
+ * @param apiKey - Clave de API de Google Maps (opcional, usa la predeterminada si no se proporciona)
+ * @returns URL del mapa estático
+ */
+export declare const getStaticMapUrl: (latitude: number | string, longitude: number | string, zoom?: number, width?: number, height?: number, markerColor?: string, apiKey?: string) => string;
+/**
+ * Geocodifica una dirección para obtener sus coordenadas
+ * @param address - La dirección a geocodificar
+ * @returns Una promesa que resuelve a un objeto con lat y lng, o null si ocurre un error
+ */
+export declare const geocodeAddress: (address: string) => Promise<{
+    lat: string;
+    lng: string;
+} | null>;

package/dist/types/components/EventsDialog/utils/googleMapsUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-exportaciones de googleMapsLoader para mantener compatibilidad
+ * Este archivo actúa como alias para las funciones de Google Maps
+ */
+export { GOOGLE_MAPS_CONFIG, GOOGLE_MAPS_SCRIPT_CONFIG, useGoogleMapsLoader, loadGoogleMapsAsync, getStaticMapUrl, geocodeAddress, } from './googleMapsLoader';

package/dist/types/components/EventsDialog/utils/isNumber.d.ts

@@ -0,0 +1 @@
+export declare function isNumber(valor: any): valor is number;

package/dist/types/components/EventsDialog/utils/keyboardNavigation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Utilidades para navegación por teclado en el calendario
+ */
+type View = 'month' | 'week' | 'day' | 'work_week' | 'agenda';
+export interface KeyboardNavigationConfig {
+    onNavigate: (action: 'PREV' | 'NEXT' | 'TODAY' | 'DATE', date?: Date) => void;
+    onViewChange: (view: View) => void;
+    onCreateEvent?: () => void;
+    currentDate: Date;
+    currentView: View;
+}
+/**
+ * Maneja los eventos de teclado para el calendario
+ */
+export declare const handleCalendarKeyDown: (event: KeyboardEvent, config: KeyboardNavigationConfig) => void;
+/**
+ * Genera el mensaje de ayuda para atajos de teclado
+ */
+export declare const getKeyboardShortcutsHelp: () => string;
+/**
+ * Genera los atributos ARIA para el calendario
+ */
+export declare const getCalendarAriaAttributes: (currentView: View, currentDate: Date) => Record<string, string>;
+export {};

package/dist/types/components/EventsDialog/utils/roundTime.d.ts

@@ -0,0 +1,10 @@
+import { Dayjs } from 'dayjs';
+/**
+ * Redondea una fecha al siguiente intervalo de 30 minutos
+ * Ejemplos:
+ * - 16:55 → 17:00
+ * - 16:23 → 16:30
+ * - 16:45 → 17:00
+ * - 16:30 → 16:30 (ya está redondeado)
+ */
+export declare function roundToNext30Minutes(date: Dayjs | Date): Dayjs;

package/dist/types/components/index.d.ts

@@ -0,0 +1,5 @@
+export { default as ContactInfoPopup } from './ContactInfoPopup';
+export { default as EditContactModal } from './EditContactModal';
+export { default as EventsDialog } from './EventsDialog';
+export type { EventsDialogProps, EventData, TaskData } from './EventsDialog';
+export type { ModalMode, ItemType, Calendar, Contact, Notification } from './EventsDialog/types';

package/dist/types/i18n/config.d.ts

@@ -0,0 +1,2 @@
+declare const i18nInstance: import("i18next").i18n;
+export default i18nInstance;

package/dist/types/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { default as i18n } from './config';
+export { useTranslation } from 'react-i18next';

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export { i18n } from './i18n';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trii/components",
-  "version": "2.0.66",
+  "version": "2.0.69",
   "description": "Trii components package",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -9,8 +9,12 @@
     "dist"
   ],
   "scripts": {
-    "dev": "rollup -c --watch",
-    "build": "rollup -c",
+    "dev": "npm-run-all --parallel dev:types dev:js",
+    "dev:types": "tsc --watch",
+    "dev:js": "rollup -c --watch",
+    "build": "npm-run-all --serial build:types build:js",
+    "build:types": "tsc --project tsconfig.build.json --emitDeclarationOnly",
+    "build:js": "rollup -c",
     "test": "jest --watchAll --verbose",
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build"
@@ -54,10 +58,11 @@
     "@fontsource/material-icons": "^5.0.18",
     "@fontsource/roboto": "^5.0.13",
     "@mui/icons-material": "^5.15.15",
-    "@mui/material": "^5.15.15",
+    "@mui/lab": "^5.0.0-alpha.176",
+    "@mui/material": "^5.18.0",
     "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-typescript": "^11.1.4",
     "@storybook/addon-essentials": "^8.5.3",
     "@storybook/addon-interactions": "^8.5.3",
     "@storybook/addon-links": "^8.5.3",
@@ -71,17 +76,32 @@
     "@storybook/test": "^8.5.3",
     "@testing-library/jest-dom": "^6.1.3",
     "@testing-library/react": "^14.0.0",
+    "@types/google-libphonenumber": "^7.4.30",
+    "@types/google.maps": "^3.58.1",
     "@types/jest": "^29.5.5",
     "@types/react": "^18.2.23",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
     "babel-jest": "^29.7.0",
+    "esbuild": "^0.27.2",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "google-libphonenumber": "^3.2.44",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
+    "npm-run-all": "^4.1.5",
     "postcss": "^8.4.31",
     "postcss-import": "^15.1.0",
+    "prettier": "^3.8.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "rollup": "^3.29.4",
     "rollup-plugin-dts": "^6.0.2",
+    "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-postcss": "^4.0.2",
     "storybook": "^8.5.3",
     "tslib": "^2.6.2",
@@ -89,13 +109,17 @@
   },
   "peerDependencies": {
     "@emotion/react": "^11.11.4",
+    "@mui/x-date-pickers": "^8.24.0",
+    "@mui/x-date-pickers-pro": "^8.24.0",
+    "dayjs": "^1.11.19",
+    "google-libphonenumber": "^3.2.43",
+    "i18next": "^25.8.0",
+    "moment": "^2.30.1",
     "react": ">=17.0.2 <19.0.0",
-    "react-dom": ">=17.0.2 <19.0.0"
+    "react-dom": ">=17.0.2 <19.0.0",
+    "react-i18next": "^16.5.3"
   },
   "dependencies": {
-    "@mui/x-date-pickers-pro": "^7.29.4",
-    "@trii/types": "^2.10.611",
-    "dayjs": "^1.11.20",
-    "moment": "^2.30.1"
+    "@trii/types": "^2.10.612"
   }
 }