@sincpro/mobile 0.1.0

package/dist/infrastructure/workers/EventBus.js

@@ -0,0 +1,279 @@
+import { DomainEventRepository } from "../../adapters/repositories/domain_event.repository";
+import { DomainEventDeadLetterRepository } from "../../adapters/repositories/domain_event_dead_letter.repository";
+import { InternetIsDownEvent, InternetIsUpEvent, QueueEndEvent, QueueStartEvent, } from "../../domain/events";
+import { DomainNetworkError } from "../../exceptions";
+import { loggerQueueProcessor } from "../../infrastructure/logger";
+import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
+export const PROCESS_WORKER_MAX_ATTEMPTS = 1;
+export class EventBus {
+    static MAX_ATTEMPTS = PROCESS_WORKER_MAX_ATTEMPTS;
+    static INTERVAL_MS = 800;
+    static MAX_INTERVAL_MS = 30000;
+    static BACKOFF_MULTIPLIER = 1.5;
+    static subscribers = new Map();
+    static isDraining = false;
+    static intervalId = null;
+    static internetConnected = true;
+    static consecutiveFailures = 0;
+    static currentInterval = EventBus.INTERVAL_MS;
+    static initConnectivityListeners() {
+        UIEventBus.on(InternetIsDownEvent.name, () => {
+            this.internetConnected = false;
+            this.consecutiveFailures++;
+            this.adjustInterval();
+            loggerQueueProcessor.warn("[NET] offline – Solo eventos locales");
+        });
+        UIEventBus.on(InternetIsUpEvent.name, () => {
+            if (!this.internetConnected) {
+                this.internetConnected = true;
+                this.consecutiveFailures = 0;
+                this.currentInterval = this.INTERVAL_MS;
+                this.restartPolling();
+                loggerQueueProcessor.info("[NET] online – Reanudando eventos de red");
+            }
+        });
+    }
+    static adjustInterval() {
+        if (this.consecutiveFailures > 0) {
+            this.currentInterval = Math.min(this.INTERVAL_MS * Math.pow(this.BACKOFF_MULTIPLIER, this.consecutiveFailures), this.MAX_INTERVAL_MS);
+            loggerQueueProcessor.debug(`Adjusted polling interval to ${this.currentInterval}ms due to ${this.consecutiveFailures} failures`);
+        }
+    }
+    static restartPolling() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+        this.intervalId = setInterval(() => this.triggerProcessing(), this.currentInterval);
+    }
+    static async triggerProcessing() {
+        if (this.isDraining)
+            return;
+        this.isDraining = true;
+        try {
+            await this.drainAll();
+            if (this.consecutiveFailures > 0) {
+                this.consecutiveFailures = 0;
+                this.currentInterval = this.INTERVAL_MS;
+                this.restartPolling();
+            }
+        }
+        catch (error) {
+            this.consecutiveFailures++;
+            this.adjustInterval();
+            this.restartPolling();
+            loggerQueueProcessor.warn("Error in processing cycle:", error);
+        }
+        finally {
+            this.isDraining = false;
+        }
+    }
+    static start() {
+        this.initConnectivityListeners();
+        if (this.intervalId)
+            return;
+        this.currentInterval = this.INTERVAL_MS;
+        this.consecutiveFailures = 0;
+        this.intervalId = setInterval(() => this.triggerProcessing(), this.currentInterval);
+        loggerQueueProcessor.info("ProcessWorker polling started");
+    }
+    static stop() {
+        if (this.intervalId)
+            clearInterval(this.intervalId);
+        this.intervalId = null;
+        loggerQueueProcessor.info("ProcessWorker polling stopped");
+    }
+    /**
+     * Waits for current processing cycle to complete (if any).
+     * Use before clean() to ensure graceful shutdown.
+     * Timeout after 5 seconds to prevent infinite wait.
+     */
+    static async waitForIdle() {
+        if (!this.isDraining)
+            return;
+        const maxWait = 5000;
+        const checkInterval = 100;
+        let waited = 0;
+        while (this.isDraining && waited < maxWait) {
+            await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        if (this.isDraining) {
+            loggerQueueProcessor.warn("EventBus waitForIdle timed out after 5s");
+        }
+    }
+    /**
+     * Validates event, logs start, emits START.
+     * Returns false if no subscribers (caller should return early).
+     */
+    static preProcess(event) {
+        const hasSubscribers = this.subscribers.has(event.name);
+        loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] (attempt ${event.attempts}/${EventBus.MAX_ATTEMPTS}) - STARTED`);
+        loggerQueueProcessor.debug(`EVENT=${event.name} uuid=${event.uuid} payload=${event.asJSON()}`);
+        const queueStartEvent = QueueStartEvent.create();
+        UIEventBus.emit(queueStartEvent.name, {
+            event: event.name,
+            label: event.label,
+            attempts: event.attempts,
+            attemptLimit: EventBus.MAX_ATTEMPTS,
+        });
+        if (!hasSubscribers) {
+            loggerQueueProcessor.warn(`EVENT=${event.name} [${event.label}] - No subscribers registered`);
+        }
+        return hasSubscribers;
+    }
+    /**
+     * Handles persistence, emits event and END, logs result.
+     * If errors is empty -> success, otherwise -> failure + dead letter + throws.
+     * @throws Error if there are any errors
+     */
+    static async postProcess(event, errors) {
+        const success = errors.length === 0;
+        const errorMessage = errors.join("; ") || undefined;
+        if (success) {
+            event.markAsAcknowledged();
+            await DomainEventRepository.save(event);
+            loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] (attempt ${event.attempts}/${EventBus.MAX_ATTEMPTS}) - FINISHED`);
+        }
+        else {
+            event.markAsFailed(errorMessage);
+            await DomainEventRepository.save(event);
+            await DomainEventDeadLetterRepository.save(event, errorMessage);
+            loggerQueueProcessor.warn(`EVENT=${event.name} [${event.label}] (attempt ${event.attempts}/${EventBus.MAX_ATTEMPTS}) - FAILED: ${errorMessage}`);
+        }
+        UIEventBus.emit(event.name, event);
+        UIEventBus.emit(QueueEndEvent.name, {
+            event: event.name,
+            label: event.label,
+            success,
+            attempts: event.attempts,
+            attemptLimit: EventBus.MAX_ATTEMPTS,
+            error: errorMessage,
+        });
+        if (!success) {
+            throw new Error(errorMessage);
+        }
+    }
+    static async executeSubscribers(event, subscriberList) {
+        const errors = [];
+        for (const subscriber of subscriberList) {
+            try {
+                const typedEvent = subscriber.getEvent(event);
+                await subscriber.process(typedEvent);
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                errors.push(errorMessage);
+                loggerQueueProcessor.warn(`EVENT=${event.name} - Subscriber failed: ${errorMessage}`);
+                if (err instanceof DomainNetworkError) {
+                    this.internetConnected = false;
+                    UIEventBus.emit(InternetIsDownEvent.name);
+                }
+            }
+        }
+        return errors;
+    }
+    /**
+     * Registers a subscriber for DomainEvent classes.
+     * A subscriber can listen to multiple events.
+     * Multiple subscribers can listen to the same event.
+     * Prevents duplicate registration of the same subscriber instance.
+     */
+    static on(subscriber) {
+        for (const EventClass of subscriber.listen) {
+            if (!EventClass) {
+                loggerQueueProcessor.error(`Undefined event class in subscriber: ${subscriber.constructor.name}`);
+                continue;
+            }
+            const staticName = EventClass.name;
+            const eventName = staticName && staticName !== "DomainEvent" ? staticName : new EventClass().name;
+            if (!this.subscribers.has(eventName)) {
+                this.subscribers.set(eventName, []);
+            }
+            const subscriberList = this.subscribers.get(eventName);
+            if (subscriberList.includes(subscriber)) {
+                loggerQueueProcessor.info(`Subscriber already registered for [${eventName}] - skipping`);
+                continue;
+            }
+            subscriberList.push(subscriber);
+            loggerQueueProcessor.info(`Subscriber registered for [${eventName}]`);
+        }
+    }
+    static off(subscriber) {
+        for (const EventClass of subscriber.listen) {
+            if (!EventClass)
+                continue;
+            const staticName = EventClass.name;
+            const eventName = staticName && staticName !== "DomainEvent" ? staticName : new EventClass().name;
+            const subscriberList = this.subscribers.get(eventName);
+            if (!subscriberList)
+                continue;
+            const index = subscriberList.indexOf(subscriber);
+            if (index > -1) {
+                subscriberList.splice(index, 1);
+                loggerQueueProcessor.info(`Subscriber unregistered for [${eventName}]`);
+            }
+            if (subscriberList.length === 0) {
+                this.subscribers.delete(eventName);
+            }
+        }
+    }
+    /**
+     * Publishes a DomainEvent asynchronously - enqueues for later processing.
+     */
+    static async publish(event) {
+        loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] - Published ASYNC`);
+        await DomainEventRepository.save(event);
+        this.triggerProcessing();
+    }
+    /**
+     * Publishes a DomainEvent synchronously - executes all subscribers immediately.
+     * Saves event to DB for traceability. Moves to dead letter on failure.
+     * @throws Error if any subscriber fails or no subscribers registered
+     */
+    static async publishSync(event) {
+        loggerQueueProcessor.info(`EVENT=${event.name} [${event.label}] - Published SYNC`);
+        event.markAsProcessing();
+        await DomainEventRepository.save(event);
+        if (!this.preProcess(event)) {
+            await this.postProcess(event, ["No subscribers registered"]);
+            return;
+        }
+        const subscriberList = this.subscribers.get(event.name);
+        const errors = await this.executeSubscribers(event, subscriberList);
+        await this.postProcess(event, errors);
+    }
+    /**
+     * Processes all pending DomainEvents from the domain_events table.
+     * Executes ALL subscribers registered for each event.
+     * Moves to dead letter queue on failure.
+     */
+    static async drainAll() {
+        let event;
+        while ((event = await DomainEventRepository.findNextPending(this.internetConnected))) {
+            try {
+                event.markAsProcessing();
+                await DomainEventRepository.save(event);
+                if (!this.preProcess(event)) {
+                    await this.postProcess(event, ["No subscribers registered"]);
+                    continue;
+                }
+                const subscriberList = this.subscribers.get(event.name);
+                const errors = await this.executeSubscribers(event, subscriberList);
+                await this.postProcess(event, errors);
+            }
+            catch { }
+        }
+    }
+    /**
+     * Clears the event queue (domain_events table).
+     */
+    static async clearQueue() {
+        try {
+            await DomainEventRepository.clearAll();
+            loggerQueueProcessor.info("ProcessWorker queue cleared");
+        }
+        catch (error) {
+            loggerQueueProcessor.warn("Failed to clear ProcessWorker queue:", error);
+        }
+    }
+}

package/dist/infrastructure/workers/index.d.ts

@@ -0,0 +1,2 @@
+export { CronJob, CronWorker } from "./CronWorker";
+export { EventBus, EventName } from "./EventBus";

package/dist/infrastructure/workers/index.js

@@ -0,0 +1,2 @@
+export { CronWorker } from "./CronWorker";
+export { EventBus } from "./EventBus";

package/dist/services/bluetooth.service.d.ts

@@ -0,0 +1,14 @@
+import { BluetoothPermissionStatus, BluetoothStatus } from "../domain/connectivity";
+declare class BluetoothService {
+    private permissionStatus;
+    requestPermissions(): Promise<BluetoothPermissionStatus>;
+    checkPermissions(): Promise<BluetoothPermissionStatus>;
+    getStatus(): Promise<BluetoothStatus>;
+    ensurePermissions(): Promise<boolean>;
+    ensurePermissionsForPrinter(): Promise<boolean>;
+    getCachedPermissions(): BluetoothPermissionStatus | null;
+    isPermissionGranted(): boolean;
+    private showPermissionToast;
+}
+export declare const bluetoothService: BluetoothService;
+export {};

package/dist/services/bluetooth.service.js

@@ -0,0 +1,72 @@
+import { BluetoothAdapter } from "../adapters/Bluetooth.adapter";
+import { loggerUseCases } from "../infrastructure/logger";
+import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
+import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+class BluetoothService {
+    permissionStatus = null;
+    async requestPermissions() {
+        loggerUseCases.info("Requesting Bluetooth permissions");
+        const permissions = await BluetoothAdapter.requestPermissions();
+        this.permissionStatus = permissions;
+        this.showPermissionToast(permissions);
+        return permissions;
+    }
+    async checkPermissions() {
+        loggerUseCases.info("Checking Bluetooth permissions");
+        const permissions = await BluetoothAdapter.hasPermissions();
+        this.permissionStatus = permissions;
+        return permissions;
+    }
+    async getStatus() {
+        loggerUseCases.info("Getting Bluetooth status");
+        return BluetoothAdapter.getStatus();
+    }
+    async ensurePermissions() {
+        loggerUseCases.info("Ensuring Bluetooth permissions are granted");
+        const currentPermissions = await this.checkPermissions();
+        if (currentPermissions.isGranted) {
+            loggerUseCases.info("Bluetooth permissions already granted");
+            return true;
+        }
+        loggerUseCases.info("Bluetooth permissions not granted, requesting...");
+        const requestedPermissions = await this.requestPermissions();
+        return requestedPermissions.isGranted;
+    }
+    async ensurePermissionsForPrinter() {
+        loggerUseCases.info("Ensuring Bluetooth permissions for printer connection");
+        const permissions = await this.ensurePermissions();
+        if (!permissions) {
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Permisos de Bluetooth requeridos",
+                text2: "Habilita los permisos de Bluetooth en configuración",
+            });
+        }
+        return permissions;
+    }
+    getCachedPermissions() {
+        return this.permissionStatus;
+    }
+    isPermissionGranted() {
+        return this.permissionStatus?.isGranted ?? false;
+    }
+    showPermissionToast(permissions) {
+        if (permissions.isGranted) {
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "success",
+                text1: "Bluetooth habilitado",
+                text2: "Permisos de Bluetooth concedidos",
+            });
+            loggerUseCases.info("Bluetooth permissions granted");
+        }
+        else {
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Bluetooth no disponible",
+                text2: "Los permisos de Bluetooth fueron denegados",
+            });
+            loggerUseCases.warn("Bluetooth permissions denied", { permissions });
+        }
+    }
+}
+export const bluetoothService = new BluetoothService();

package/dist/services/database_table.service.d.ts

@@ -0,0 +1,8 @@
+import { IDatabaseTable } from "../domain/database";
+declare class DatabaseTablesUseCase {
+    private get repository();
+    getAllTables(): Promise<IDatabaseTable[]>;
+    getTableData(tableName: string): Promise<any[]>;
+}
+export declare const databaseTablesUseCase: DatabaseTablesUseCase;
+export {};

package/dist/services/database_table.service.js

@@ -0,0 +1,19 @@
+import { ECommonRepository, repos } from "../entrypoints/db";
+import { loggerUseCases } from "../infrastructure/logger";
+class DatabaseTablesUseCase {
+    get repository() {
+        return repos.get(ECommonRepository.DATABASE_TABLE);
+    }
+    async getAllTables() {
+        loggerUseCases.info("Getting all database tables");
+        const tables = await this.repository.findAll();
+        return tables.toArray();
+    }
+    async getTableData(tableName) {
+        loggerUseCases.info(`Getting data for ${tableName}`);
+        const result = await this.repository.getTableData(tableName);
+        loggerUseCases.info(`Retrieved ${result.length} records from ${tableName}`);
+        return result;
+    }
+}
+export const databaseTablesUseCase = new DatabaseTablesUseCase();

package/dist/services/dead_letter_queue.service.d.ts

@@ -0,0 +1,38 @@
+import { DomainEvent } from "../domain/event_sourcing";
+declare class DeadLetterQueueUseCases {
+    private get repository();
+    /**
+     * Retrieves all failed events from the dead letter queue.
+     */
+    getFailedEvents(): Promise<DomainEvent[]>;
+    /**
+     * Retrieves a specific failed event by uuid.
+     */
+    getFailedEventById(uuid: string): Promise<DomainEvent | null>;
+    /**
+     * Manually retries a failed event by re-queuing it for processing.
+     * This removes the event from the dead letter queue and adds it back to the processing queue.
+     */
+    retryFailedEvent(event: DomainEvent): Promise<void>;
+    /**
+     * Retries multiple failed events in batch.
+     */
+    retryMultipleFailedEvents(events: DomainEvent[]): Promise<{
+        success: number;
+        failed: number;
+    }>;
+    /**
+     * Permanently deletes a failed event from the dead letter queue.
+     * Use with caution as this action cannot be undone.
+     */
+    deleteFailedEvent(event: DomainEvent): Promise<void>;
+    /**
+     * Deletes multiple failed events in batch.
+     */
+    deleteMultipleFailedEvents(events: DomainEvent[]): Promise<{
+        success: number;
+        failed: number;
+    }>;
+}
+export declare const deadLetterQueueUseCases: DeadLetterQueueUseCases;
+export {};

package/dist/services/dead_letter_queue.service.js

@@ -0,0 +1,99 @@
+import { ECommonRepository, repos } from "../entrypoints/db";
+import { loggerUseCases } from "../infrastructure/logger";
+import { EventBus } from "../infrastructure/workers/EventBus";
+class DeadLetterQueueUseCases {
+    get repository() {
+        return repos.get(ECommonRepository.DOMAIN_EVENT_DEAD_LETTER);
+    }
+    /**
+     * Retrieves all failed events from the dead letter queue.
+     */
+    async getFailedEvents() {
+        loggerUseCases.info("Fetching all failed events from dead letter queue");
+        const deadLetterEvents = await this.repository.findAll();
+        return deadLetterEvents;
+    }
+    /**
+     * Retrieves a specific failed event by uuid.
+     */
+    async getFailedEventById(uuid) {
+        loggerUseCases.info(`Fetching failed event with uuid: ${uuid}`);
+        return await this.repository.findById(uuid);
+    }
+    /**
+     * Manually retries a failed event by re-queuing it for processing.
+     * This removes the event from the dead letter queue and adds it back to the processing queue.
+     */
+    async retryFailedEvent(event) {
+        loggerUseCases.info(`Manually retrying failed event: ${event.name} (uuid: ${event.uuid})`);
+        try {
+            // Reset the event for retry
+            event.retry();
+            // Re-queue the event using V2 API
+            await EventBus.publish(event);
+            // Remove from dead letter queue only after successful re-queuing
+            await this.repository.remove(event.uuid);
+            loggerUseCases.info(`Successfully retried event: ${event.name} (uuid: ${event.uuid})`);
+        }
+        catch (error) {
+            loggerUseCases.error(`Failed to retry event ${event.name} (uuid: ${event.uuid}):`, error);
+            throw new Error(`Failed to retry event: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Retries multiple failed events in batch.
+     */
+    async retryMultipleFailedEvents(events) {
+        loggerUseCases.info(`Batch retrying ${events.length} failed events`);
+        let successCount = 0;
+        let failedCount = 0;
+        for (const event of events) {
+            try {
+                await this.retryFailedEvent(event);
+                successCount++;
+            }
+            catch (error) {
+                loggerUseCases.error(`Failed to retry event ${event.name} (uuid: ${event.uuid}):`, error);
+                failedCount++;
+            }
+        }
+        loggerUseCases.info(`Batch retry completed: ${successCount} successful, ${failedCount} failed`);
+        return { success: successCount, failed: failedCount };
+    }
+    /**
+     * Permanently deletes a failed event from the dead letter queue.
+     * Use with caution as this action cannot be undone.
+     */
+    async deleteFailedEvent(event) {
+        loggerUseCases.info(`Permanently deleting failed event: ${event.name} (uuid: ${event.uuid})`);
+        try {
+            await this.repository.remove(event.uuid);
+            loggerUseCases.info(`Successfully deleted event: ${event.name} (uuid: ${event.uuid})`);
+        }
+        catch (error) {
+            loggerUseCases.error(`Failed to delete event ${event.name} (uuid: ${event.uuid}):`, error);
+            throw new Error(`Failed to delete event: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Deletes multiple failed events in batch.
+     */
+    async deleteMultipleFailedEvents(events) {
+        loggerUseCases.info(`Batch deleting ${events.length} failed events`);
+        let successCount = 0;
+        let failedCount = 0;
+        for (const event of events) {
+            try {
+                await this.deleteFailedEvent(event);
+                successCount++;
+            }
+            catch (error) {
+                loggerUseCases.error(`Failed to delete event ${event.name} (uuid: ${event.uuid}):`, error);
+                failedCount++;
+            }
+        }
+        loggerUseCases.info(`Batch delete completed: ${successCount} successful, ${failedCount} failed`);
+        return { success: successCount, failed: failedCount };
+    }
+}
+export const deadLetterQueueUseCases = new DeadLetterQueueUseCases();

package/dist/services/event.service.d.ts

@@ -0,0 +1,7 @@
+import { DomainEvent } from "../domain/event_sourcing";
+declare class EventService {
+    listAllEvents(): Promise<DomainEvent[]>;
+    republishSync(event: DomainEvent): Promise<void>;
+}
+export declare const eventService: EventService;
+export {};

package/dist/services/event.service.js

@@ -0,0 +1,24 @@
+import { DomainEventRepository } from "../adapters/repositories/domain_event.repository";
+import { EEventStatus } from "../domain/event_sourcing";
+import { loggerUseCases } from "../infrastructure/logger";
+import { EventBus } from "../infrastructure/workers/EventBus";
+class EventService {
+    async listAllEvents() {
+        loggerUseCases.info("Fetching all events from DomainEvent repository");
+        // Ordered by created_at DESC from repository query
+        const pending = await DomainEventRepository.findByStatuses([
+            EEventStatus.PENDING,
+            EEventStatus.PROCESSING,
+            EEventStatus.ACKNOWLEDGED,
+            EEventStatus.FAILED,
+            EEventStatus.CANCELLED,
+        ]);
+        return pending;
+    }
+    async republishSync(event) {
+        const cloned = event.cloneWithReset();
+        loggerUseCases.info(`Republishing event sync: ${cloned.name} (${cloned.uuid})`);
+        await EventBus.publishSync(cloned);
+    }
+}
+export const eventService = new EventService();

package/dist/services/network.service.d.ts

@@ -0,0 +1,7 @@
+import { NetworkStatus } from "../domain/connectivity";
+export declare class NetworkUseCases {
+    private networkStatus;
+    getNetworkStatus(): Promise<NetworkStatus>;
+    showToastNotification(networkStatus: NetworkStatus): Promise<void>;
+}
+export declare const networkUseCases: NetworkUseCases;

package/dist/services/network.service.js

@@ -0,0 +1,43 @@
+import { NetworkAdapter } from "../adapters/Network.adapter";
+import { InternetIsDownEvent, InternetIsUpEvent } from "../domain/events";
+import { loggerUseCases } from "../infrastructure/logger";
+import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
+import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+export class NetworkUseCases {
+    networkStatus = null;
+    async getNetworkStatus() {
+        const networkStatus = await NetworkAdapter.getStatus();
+        if (networkStatus.isConnected) {
+            UIEventBus.emit(InternetIsUpEvent.name, true);
+        }
+        else {
+            UIEventBus.emit(InternetIsDownEvent.name, false);
+        }
+        this.showToastNotification(networkStatus);
+        this.networkStatus = networkStatus;
+        return this.networkStatus;
+    }
+    async showToastNotification(networkStatus) {
+        const showToast = networkStatus.isConnected !== this.networkStatus?.isConnected;
+        if (!showToast) {
+            return;
+        }
+        if (!networkStatus.isConnected) {
+            loggerUseCases.info(`Network is up: ${networkStatus.type}`);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Estas desconectado",
+                text2: "Sin conexión a internet",
+            });
+        }
+        else {
+            loggerUseCases.warn(`Network is down: ${networkStatus.type}`);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "success",
+                text1: "Conectado",
+                text2: `Conexión a través de ${networkStatus.type}`,
+            });
+        }
+    }
+}
+export const networkUseCases = new NetworkUseCases();

package/dist/services/printer.service.d.ts

@@ -0,0 +1,25 @@
+import { type BluetoothDevice, type IPrinterDriver, type ISelectedPrinter, type PairedPrinter } from "../domain/print";
+import type { RefObject } from "react";
+import type { View } from "react-native";
+declare class PrinterService {
+    private readonly bluetooth;
+    private cachedPrinter;
+    setDriver(driver: IPrinterDriver): void;
+    hasDriver(): boolean;
+    getPairedDevices(): BluetoothDevice[];
+    getPairedPrinters(): PairedPrinter[];
+    isConnected(): boolean;
+    connect(address: string, name: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+    getSelectedPrinter(): Promise<ISelectedPrinter | null>;
+    saveSelectedPrinter(printer: ISelectedPrinter): Promise<void>;
+    clearSelectedPrinter(): Promise<void>;
+    printTestPage(): Promise<boolean>;
+    printImageBase64(base64Data: string): Promise<boolean>;
+    printFromView(viewRef: RefObject<View | null>): Promise<boolean>;
+    printHtml(html: string): Promise<boolean>;
+    private htmlToPdfBase64;
+    private ensureConnected;
+}
+export declare const printerService: PrinterService;
+export {};