@sincpro/mobile 0.4.3 → 1.0.0

package/dist/services/printer.service.js

@@ -3,8 +3,7 @@ import { SettingsRepository } from "../adapters/repositories/setting.repository"
 import { getPrinterDriver, hasPrinterDriver, setPrinterDriver, } from "../domain/print";
 import { ECommonSetting } from "../domain/settings";
 import { loggerUseCases } from "../infrastructure/logger";
-import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
-import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+import { notifyDevice } from "../infrastructure/ui/activity";
 import { File } from "expo-file-system";
 import * as Print from "expo-print";
 import { bluetoothService } from "./bluetooth.service";
@@ -26,7 +25,7 @@ class PrinterService {
     isConnected() {
         return getPrinterDriver().isConnected();
     }
-    async connect(address, name) {
+    async connect(address, name, notify = true) {
         const hasPermissions = await this.bluetooth.ensurePermissionsForPrinter();
         if (!hasPermissions) {
             return false;
@@ -39,30 +38,37 @@ class PrinterService {
                 selectedAt: new Date().toISOString(),
             };
             await this.saveSelectedPrinter(printer);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresora conectada",
-                text2: `Conectado a ${name}`,
-            });
+            if (notify) {
+                notifyDevice({
+                    name: "printer.connected",
+                    title: "Impresora conectada",
+                    message: `Conectado a ${name}`,
+                    variant: "success",
+                });
+            }
             return true;
         }
         catch (error) {
             loggerUseCases.error(`Failed to connect to printer: ${name}`, error);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Error de conexión",
-                text2: `No se pudo conectar a ${name}`,
-            });
+            if (notify) {
+                notifyDevice({
+                    name: "printer.connect_failed",
+                    title: "Error de conexión",
+                    message: `No se pudo conectar a ${name}`,
+                    variant: "danger",
+                });
+            }
             return false;
         }
     }
     async disconnect() {
         try {
             await getPrinterDriver().disconnect();
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "info",
-                text1: "Desconectado",
-                text2: "Impresora desconectada",
+            notifyDevice({
+                name: "printer.disconnected",
+                title: "Desconectado",
+                message: "Impresora desconectada",
+                variant: "info",
             });
         }
         catch (error) {
@@ -87,10 +93,11 @@ class PrinterService {
     }
     async printTestPage() {
         if (!this.isConnected()) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Sin conexión",
-                text2: "Conecta una impresora primero",
+            notifyDevice({
+                name: "printer.not_connected",
+                title: "Sin conexión",
+                message: "Conecta una impresora primero",
+                variant: "danger",
             });
             return false;
         }
@@ -108,19 +115,21 @@ class PrinterService {
                 alignment: "center",
                 fontSize: "small",
             });
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresión exitosa",
-                text2: "Página de prueba impresa",
+            notifyDevice({
+                name: "printer.test_ok",
+                title: "Impresión exitosa",
+                message: "Página de prueba impresa",
+                variant: "success",
             });
             return true;
         }
         catch (error) {
             loggerUseCases.error("Error printing test page", error);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Error de impresión",
-                text2: "No se pudo imprimir la página de prueba",
+            notifyDevice({
+                name: "printer.test_failed",
+                title: "Error de impresión",
+                message: "No se pudo imprimir la página de prueba",
+                variant: "danger",
             });
             return false;
         }
@@ -137,18 +146,13 @@ class PrinterService {
             loggerUseCases.warn("Print failed — attempting grace reconnect", firstError);
             const reconnected = await this.forceReconnect();
             if (!reconnected)
-                return false; // connect() ya notificó al usuario
+                return false;
             try {
                 await getPrinterDriver().printImageBase64(base64Data);
                 return true;
             }
             catch (retryError) {
                 loggerUseCases.error("Print retry after reconnect also failed", retryError);
-                UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                    type: "error",
-                    text1: "Error de impresión",
-                    text2: "No se pudo imprimir incluso tras reconectar la impresora",
-                });
                 return false;
             }
         }
@@ -164,10 +168,11 @@ class PrinterService {
                 return false;
             }
             await getPrinterDriver().printImageBase64(imageBase64);
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "success",
-                text1: "Impresión enviada",
-                text2: "Documento enviado a la impresora",
+            notifyDevice({
+                name: "printer.sent",
+                title: "Impresión enviada",
+                message: "Documento enviado a la impresora",
+                variant: "success",
             });
             return true;
         }
@@ -233,7 +238,7 @@ class PrinterService {
         if (!printer)
             return false;
         loggerUseCases.info(`Grace reconnect: reconnecting to ${printer.name} (${printer.address})`);
-        return this.connect(printer.address, printer.name);
+        return this.connect(printer.address, printer.name, false);
     }
     async ensureConnected() {
         if (this.isConnected()) {
@@ -241,10 +246,11 @@ class PrinterService {
         }
         const printer = await this.getSelectedPrinter();
         if (!printer) {
-            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
-                type: "error",
-                text1: "Sin impresora",
-                text2: "Selecciona una impresora primero",
+            notifyDevice({
+                name: "printer.missing",
+                title: "Sin impresora",
+                message: "Selecciona una impresora primero",
+                variant: "danger",
             });
             return false;
         }

package/dist/tools/utils/date.js

@@ -1,3 +1,4 @@
+import { dayOf, isDay } from "@sincpro/client-framework";
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone";
 import utc from "dayjs/plugin/utc";
@@ -53,7 +54,7 @@ export function formatDate(input, timezone, options) {
     const usedLocale = options?.locale ?? deviceLocale;
     try {
         const rawStr = typeof input === "string" ? input : input.toISOString();
-        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(rawStr);
+        const isDateOnly = typeof input === "string" && isDay(input);
         // Auto-detect showTime si no se pasa explicitamente
         const effectiveShowTime = options?.showTime !== undefined
             ? options.showTime
@@ -100,11 +101,11 @@ export function formatDateWithDefaultTimezone(input, options) {
 export function getCurrentDateInTimezone(timezone) {
     const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
     try {
-        return dayjs().tz(effectiveTimezone).format("YYYY-MM-DD");
+        return dayOf(new Date().toISOString(), effectiveTimezone) ?? dayjs().format("YYYY-MM-DD");
     }
     catch (error) {
         console.warn("Error obteniendo fecha actual en timezone:", error);
-        return dayjs().format("YYYY-MM-DD"); // Fallback to local
+        return dayjs().format("YYYY-MM-DD");
     }
 }
 /**

package/dist/tools/utils/monetary.d.ts

@@ -1,3 +1,6 @@
-export declare function parseToMonetaryNumber(input?: string | number | null): number;
-export declare function formatTwoDecimals(value?: number | string | null): string;
-export declare function calculateDiscountedTotal(total: number, discount: number): number;
+import { Decimal, type DecimalLike } from "@sincpro/client-framework";
+export declare function toDecimal(input?: DecimalLike | null): Decimal;
+export declare function parseToMonetaryNumber(input?: DecimalLike | null): Decimal;
+export declare function formatTwoDecimals(value?: DecimalLike | null): string;
+export declare function discountOf(total: DecimalLike, discount: DecimalLike): Decimal;
+export declare function calculateDiscountedTotal(total: DecimalLike, discount: DecimalLike): Decimal;

package/dist/tools/utils/monetary.js

@@ -1,31 +1,43 @@
-import { Big } from "big.js";
-export function parseToMonetaryNumber(input) {
+import { Decimal } from "@sincpro/client-framework";
+export function toDecimal(input) {
     if (input == null)
-        return 0;
-    const s = String(input).trim();
-    if (!/[0-9]/.test(s))
-        return 0;
-    const cleaned = s.replace(/[^0-9.-]+/g, "");
+        return new Decimal(0);
+    if (typeof input === "number" && !Number.isFinite(input))
+        return new Decimal(0);
+    if (typeof input === "string") {
+        const text = input.trim();
+        if (!/[0-9]/.test(text))
+            return new Decimal(0);
+        try {
+            return new Decimal(text.replace(/[^0-9.-]+/g, ""));
+        }
+        catch {
+            return new Decimal(0);
+        }
+    }
     try {
-        return Number(new Big(cleaned).toString());
+        return new Decimal(input);
     }
     catch {
-        return 0;
+        return new Decimal(0);
     }
 }
+export function parseToMonetaryNumber(input) {
+    return toDecimal(input);
+}
 export function formatTwoDecimals(value) {
-    const raw = parseToMonetaryNumber(value);
-    const rounded = new Big(raw).toFixed(2);
-    const num = Number(rounded);
-    return new Intl.NumberFormat("de-DE", {
-        minimumFractionDigits: 2,
-        maximumFractionDigits: 2,
-    }).format(num);
+    const text = toDecimal(value).rounded(2).toString();
+    const negative = text.startsWith("-");
+    const [whole, fraction = "00"] = (negative ? text.slice(1) : text).split(".");
+    const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+    return `${negative ? "-" : ""}${grouped},${fraction}`;
+}
+export function discountOf(total, discount) {
+    const rate = toDecimal(discount);
+    if (rate.isZero)
+        return new Decimal(0);
+    return toDecimal(total).times(rate).dividedBy(100, 8);
 }
 export function calculateDiscountedTotal(total, discount) {
-    if (discount === 0) {
-        return 0;
-    }
-    const result = (parseToMonetaryNumber(total) * discount) / 100;
-    return parseToMonetaryNumber(result);
+    return discountOf(total, discount);
 }

package/dist/tools/utils/serializer.d.ts

@@ -1,2 +1,2 @@
-export declare function safeJsonStringify(obj: any, pretty?: boolean): string;
+export declare function safeJsonStringify(obj: unknown, pretty?: boolean): string;
 export declare function safeJsonParse(json: string): any;

package/dist/tools/utils/serializer.js

@@ -1,44 +1,41 @@
-export function safeJsonStringify(obj, pretty = false) {
-    const seen = new WeakSet();
-    if (pretty) {
-        return JSON.stringify(obj, (key, value) => {
-            if (key.startsWith("_")) {
-                return undefined;
-            }
-            if (value instanceof Map) {
-                return Object.fromEntries(value);
-            }
-            if (value instanceof Set) {
-                return Array.from(value);
-            }
-            if (typeof value === "object" && value !== null) {
-                if (seen.has(value)) {
-                    return "[Circular]";
-                }
-                seen.add(value);
-            }
-            return value;
-        }, 2);
+import { readValues, valuesOf } from "@sincpro/client-framework";
+function publishable(value, seen) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (seen.has(value))
+        return "[Circular]";
+    if (value instanceof Uint8Array ||
+        value instanceof ArrayBuffer ||
+        value instanceof DataView ||
+        typeof value.toJSON === "function") {
+        return value;
     }
-    return JSON.stringify(obj, (key, value) => {
-        if (key.startsWith("_")) {
-            return undefined;
-        }
+    seen.add(value);
+    try {
         if (value instanceof Map) {
-            return Object.fromEntries(value);
+            return new Map([...value].map(([key, item]) => [key, publishable(item, seen)]));
         }
         if (value instanceof Set) {
-            return Array.from(value);
+            return new Set([...value].map((item) => publishable(item, seen)));
         }
-        if (typeof value === "object" && value !== null) {
-            if (seen.has(value)) {
-                return "[Circular]";
-            }
-            seen.add(value);
+        if (Array.isArray(value))
+            return value.map((item) => publishable(item, seen));
+        const published = {};
+        for (const [key, item] of Object.entries(value)) {
+            if (key.startsWith("_") || typeof item === "function")
+                continue;
+            published[key] = publishable(item, seen);
         }
-        return value;
-    });
+        return published;
+    }
+    finally {
+        seen.delete(value);
+    }
+}
+export function safeJsonStringify(obj, pretty = false) {
+    const wire = valuesOf(publishable(obj, new WeakSet()));
+    return JSON.stringify(wire, null, pretty ? 2 : undefined);
 }
 export function safeJsonParse(json) {
-    return JSON.parse(json);
+    return readValues(json);
 }

package/dist/ui/activity/DeviceNotices.d.ts

@@ -0,0 +1 @@
+export declare function DeviceNotices(): null;

package/dist/ui/activity/DeviceNotices.js

@@ -0,0 +1,29 @@
+import { textOf } from "../../domain/events/label";
+import { useCommon } from "../../entrypoints/ui/common_provider";
+import { useToast } from "@sincpro/mobile-ui/Feedback";
+import { useEffect, useRef } from "react";
+import { useActivity } from "./useActivity";
+const VARIANT = {
+    success: "success",
+    danger: "danger",
+    info: "info",
+};
+export function DeviceNotices() {
+    const { notices } = useActivity();
+    const { locale } = useCommon();
+    const toast = useToast();
+    const shownRef = useRef(new Set());
+    useEffect(() => {
+        for (const notice of notices) {
+            if (shownRef.current.has(notice.id))
+                continue;
+            shownRef.current.add(notice.id);
+            toast.show({
+                title: textOf(notice.label, locale),
+                message: textOf(notice.detail ?? notice.label, locale),
+                variant: VARIANT[notice.variant ?? "info"],
+            });
+        }
+    }, [locale, notices, toast]);
+    return null;
+}

package/dist/ui/activity/ProcessToast.d.ts

@@ -0,0 +1,2 @@
+declare function ProcessToast(): null;
+export default ProcessToast;

package/dist/ui/activity/ProcessToast.js

@@ -0,0 +1,71 @@
+import { textOf } from "../../domain/events/label";
+import { useCommon } from "../../entrypoints/ui/common_provider";
+import { useToast } from "@sincpro/mobile-ui/Feedback";
+import { useEffect, useRef } from "react";
+import { useActivity } from "./useActivity";
+const MAX_ERROR_LEN = 150;
+const MIN_VISIBLE_MS = 1200;
+function ProcessToast() {
+    const { queue, crons, failure } = useActivity();
+    const { locale } = useCommon();
+    const toast = useToast();
+    const loadingIdRef = useRef(null);
+    const shownErrorRef = useRef(null);
+    const startedAtRef = useRef(null);
+    const hideTimerRef = useRef(null);
+    const progress = queue ?? crons[0];
+    const progressLabel = textOf(progress?.label, locale);
+    useEffect(() => {
+        if (hideTimerRef.current) {
+            clearTimeout(hideTimerRef.current);
+            hideTimerRef.current = null;
+        }
+        const hideLoading = () => {
+            if (!loadingIdRef.current)
+                return;
+            toast.hide(loadingIdRef.current);
+            loadingIdRef.current = null;
+            startedAtRef.current = null;
+        };
+        if (progress && !failure) {
+            if (startedAtRef.current == null)
+                startedAtRef.current = Date.now();
+            if (loadingIdRef.current) {
+                toast.update(loadingIdRef.current, { message: progressLabel, variant: "loading" });
+            }
+            else {
+                loadingIdRef.current = toast.loading(progressLabel);
+            }
+        }
+        else if (loadingIdRef.current) {
+            const elapsed = startedAtRef.current
+                ? Date.now() - startedAtRef.current
+                : MIN_VISIBLE_MS;
+            const wait = failure ? 0 : Math.max(0, MIN_VISIBLE_MS - elapsed);
+            hideTimerRef.current = setTimeout(hideLoading, wait);
+        }
+        return () => {
+            if (hideTimerRef.current)
+                clearTimeout(hideTimerRef.current);
+        };
+    }, [failure, progress, progressLabel, toast]);
+    useEffect(() => {
+        if (!failure) {
+            shownErrorRef.current = null;
+            return;
+        }
+        if (shownErrorRef.current === failure.id)
+            return;
+        shownErrorRef.current = failure.id;
+        const raw = failure.detail != null ? textOf(failure.detail, locale) : undefined;
+        const detail = raw
+            ? raw.length > MAX_ERROR_LEN
+                ? `${raw.slice(0, MAX_ERROR_LEN)}...`
+                : raw
+            : undefined;
+        const title = textOf(failure.label, locale);
+        toast.danger(detail ?? title, { title: `Error: ${title}` });
+    }, [failure, locale, toast]);
+    return null;
+}
+export default ProcessToast;

package/dist/ui/{components/molecules → activity}/ProcessToastProvider.d.ts

@@ -1,4 +1,4 @@
 import type { ReactNode } from "react";
 export declare function ProcessToastProvider({ children }: {
     children: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/dist/ui/activity/index.d.ts

@@ -0,0 +1,4 @@
+export { DeviceNotices } from "./DeviceNotices";
+export { default as ProcessToast } from "./ProcessToast";
+export { ProcessToastProvider } from "./ProcessToastProvider";
+export { useActivity } from "./useActivity";

package/dist/ui/activity/index.js

@@ -0,0 +1,4 @@
+export { DeviceNotices } from "./DeviceNotices";
+export { default as ProcessToast } from "./ProcessToast";
+export { ProcessToastProvider } from "./ProcessToastProvider";
+export { useActivity } from "./useActivity";

package/dist/ui/activity/useActivity.d.ts

@@ -0,0 +1,9 @@
+import { type ActivityFact } from "../../infrastructure/ui/activity";
+export declare function useActivity(options?: {
+    all?: boolean;
+}): {
+    queue: ActivityFact;
+    crons: ActivityFact[];
+    failure: ActivityFact | undefined;
+    notices: ActivityFact[];
+};

package/dist/ui/activity/useActivity.js

@@ -0,0 +1,48 @@
+import { ACTIVITY_EVENT, ACTIVITY_SETTING_EVENT, activityVisible, applyActivity, emptyActivity, loadActivityEnabled, } from "../../infrastructure/ui/activity";
+import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
+import { useEffect, useMemo, useState } from "react";
+const CHANNELS_ON = {
+    queue: true,
+    cron: true,
+    device: true,
+};
+export function useActivity(options) {
+    const all = options?.all ?? false;
+    const [state, setState] = useState(emptyActivity);
+    const [enabled, setEnabled] = useState(CHANNELS_ON);
+    useEffect(() => {
+        let alive = true;
+        loadActivityEnabled().then((next) => {
+            if (alive)
+                setEnabled(next);
+        });
+        return () => {
+            alive = false;
+        };
+    }, []);
+    useEffect(() => {
+        const offFact = UIEventBus.on(ACTIVITY_EVENT, (payload) => {
+            setState((current) => applyActivity(current, payload));
+        }, { debounce: false });
+        const offSetting = UIEventBus.on(ACTIVITY_SETTING_EVENT, (payload) => {
+            const change = payload;
+            setEnabled((current) => ({ ...current, [change.channel]: change.enabled }));
+        }, { debounce: false });
+        return () => {
+            offFact();
+            offSetting();
+        };
+    }, []);
+    return useMemo(() => {
+        const visible = state.running.filter((fact) => activityVisible(fact, enabled, all));
+        const queues = visible.filter((fact) => fact.channel === "queue");
+        return {
+            queue: queues[queues.length - 1],
+            crons: visible.filter((fact) => fact.channel === "cron"),
+            failure: state.failure && activityVisible(state.failure, enabled, all)
+                ? state.failure
+                : undefined,
+            notices: state.notices.filter((fact) => activityVisible(fact, enabled, all)),
+        };
+    }, [all, enabled, state]);
+}

package/dist/ui/components/atoms/DebugBanner.d.ts

@@ -1,2 +1,2 @@
-declare function DebugBanner(): import("react/jsx-runtime").JSX.Element | null;
+declare function DebugBanner(): import("react").JSX.Element | null;
 export { DebugBanner };

package/dist/ui/components/molecules/BluetoothDeviceSelectorModal.d.ts

@@ -4,5 +4,5 @@ interface BluetoothDeviceSelectorModalProps {
     onClose: () => void;
     onSelect: (device: BluetoothDevice) => void;
 }
-declare function BluetoothDeviceSelectorModal({ visible, onClose, onSelect, }: BluetoothDeviceSelectorModalProps): import("react/jsx-runtime").JSX.Element;
+declare function BluetoothDeviceSelectorModal({ visible, onClose, onSelect, }: BluetoothDeviceSelectorModalProps): import("react").JSX.Element;
 export { BluetoothDeviceSelectorModal };

package/dist/ui/components/molecules/BluetoothDeviceSelectorModal.js

@@ -23,6 +23,13 @@ function BluetoothDeviceSelectorModal({ visible, onClose, onSelect, }) {
     const [loading, setLoading] = useState(false);
     const [selectedDevice, setSelectedDevice] = useState(null);
     const [connecting, setConnecting] = useState(false);
+    const [prevVisible, setPrevVisible] = useState(visible);
+    if (visible !== prevVisible) {
+        setPrevVisible(visible);
+        if (visible) {
+            setSelectedDevice(null);
+        }
+    }
     const loadDevices = useCallback(async () => {
         setLoading(true);
         try {
@@ -38,8 +45,7 @@ function BluetoothDeviceSelectorModal({ visible, onClose, onSelect, }) {
     }, []);
     useEffect(() => {
         if (visible) {
-            loadDevices();
-            setSelectedDevice(null);
+            Promise.resolve().then(() => loadDevices());
         }
     }, [visible, loadDevices]);
     async function handleConfirm() {

package/dist/ui/components/molecules/DeadLetterErrorBlock.d.ts

@@ -4,5 +4,5 @@ interface DeadLetterErrorBlockProps {
     onToggle: () => void;
     previewChars?: number;
 }
-declare function DeadLetterErrorBlock({ errorMessage, expanded, onToggle, previewChars, }: DeadLetterErrorBlockProps): import("react/jsx-runtime").JSX.Element | null;
+declare function DeadLetterErrorBlock({ errorMessage, expanded, onToggle, previewChars, }: DeadLetterErrorBlockProps): import("react").JSX.Element | null;
 export default DeadLetterErrorBlock;

package/dist/ui/components/molecules/EventTimelineItem.d.ts

@@ -1,7 +1,7 @@
-import { DomainEvent } from "../../../domain/event_sourcing";
+import { IntegrationEvent } from "../../../domain/events";
 interface EventTimelineItemProps {
-    event: DomainEvent;
+    event: IntegrationEvent;
     isLast?: boolean;
 }
-declare function EventTimelineItem({ event, isLast }: EventTimelineItemProps): import("react/jsx-runtime").JSX.Element;
+declare function EventTimelineItem({ event, isLast }: EventTimelineItemProps): import("react").JSX.Element;
 export default EventTimelineItem;

package/dist/ui/components/molecules/EventTimelineItem.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
-import { EEventStatus } from "../../../domain/event_sourcing";
+import { EEventStatus } from "../../../domain/events";
 import { Display } from "@sincpro/mobile-ui/Display";
 import CopyableText from "@sincpro/mobile-ui/Display/Display.CopyableText";
 import { useTheme } from "@sincpro/mobile-ui/theme";

package/dist/ui/components/molecules/GeoPermissionCard.d.ts

@@ -4,5 +4,5 @@ interface GeoPermissionCardProps {
     loading?: boolean;
     handleRequestPermission?: () => void;
 }
-declare function GeoPermissionCard({ title, loading, handleRequestPermission, hasPermission, }: GeoPermissionCardProps): import("react/jsx-runtime").JSX.Element;
+declare function GeoPermissionCard({ title, loading, handleRequestPermission, hasPermission, }: GeoPermissionCardProps): import("react").JSX.Element;
 export default GeoPermissionCard;

package/dist/ui/components/molecules/TimeZoneSelector.d.ts

@@ -3,5 +3,5 @@ interface TimeZoneSelectorProps {
     onSelect?: (tz: TimezoneLocale) => void;
     timezone?: string | null;
 }
-export declare function TimeZoneSelector({ onSelect, timezone }: TimeZoneSelectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function TimeZoneSelector({ onSelect, timezone }: TimeZoneSelectorProps): import("react").JSX.Element;
 export {};

package/dist/ui/components/molecules/TimeZoneSelectorModal.d.ts

@@ -5,5 +5,5 @@ interface TimeZoneSelectorModalProps {
     onSelect: (tz: TimezoneLocale) => void;
     currentTimezone?: string | null;
 }
-declare function TimeZoneSelectorModal({ visible, onClose, onSelect, currentTimezone, }: TimeZoneSelectorModalProps): import("react/jsx-runtime").JSX.Element;
+declare function TimeZoneSelectorModal({ visible, onClose, onSelect, currentTimezone, }: TimeZoneSelectorModalProps): import("react").JSX.Element;
 export { TimeZoneSelectorModal };