@sincpro/mobile 0.1.0

package/README.md

@@ -0,0 +1,74 @@
+# @sincpro/mobile
+
+Core del framework móvil Sincpro (React Native / Expo): infraestructura offline-first (DB, cola/eventos, cron), patrones DDD, adapters base, composición module-driven y el `AppShell`. Consume el design system `@sincpro/mobile-ui`.
+
+## Instalación
+
+```bash
+npx expo install @sincpro/mobile @sincpro/mobile-ui
+```
+
+`@sincpro/mobile-ui` es peer dependency (lo provee la app). Para integrar Odoo: `@sincpro/mobile-odoo` (opcional).
+
+## Instanciar una app
+
+Una app define sus dominios como **clases que extienden `DomainModule`** y las compone con `createAppShell`:
+
+```tsx
+import { createAppShell, createTheme, DomainModule } from "@sincpro/mobile";
+import type { Subscriber } from "@sincpro/mobile/domain/subscriber";
+
+class VentasModule extends DomainModule {
+  readonly key = "VENTAS";
+  readonly name = "Ventas";
+
+  override subscribers(): Subscriber[] {
+    return [];
+  }
+}
+
+const ventasModule = new VentasModule();
+
+export default createAppShell({
+  theme: createTheme({ primary: "#0EA5E9" }),
+  domains: [ventasModule],
+  ui: { [ventasModule.key]: VentasScreen },
+  activeDomain: ventasModule.key,
+});
+```
+
+`createAppShell` arranca la infraestructura (migraciones, EventBus, cron, orchestrator), carga fuentes, aplica el tema (a `className` y `style`) y monta el `DomainSwitcher`.
+
+## API pública
+
+- `createAppShell(config)` — composition root de la app (theme, domains, ui, activeDomain, providers).
+- `DomainModule` — clase base abstracta de un dominio (`key`, `name`, `shared?`, `repositories()`, `migrations()`, `subscribers()`, `crons()`, `persistOnReset()`).
+- `createTheme(overrides?)` — theme tipado (defaults del framework + overrides parciales).
+- `createApp(config)` / `Kernel` / `orchestrator` — capa baja de composición (bootstrap sin UI).
+- `BaseModule` / `baseModule` — módulo común (COMMON) que el framework registra por defecto.
+- `CommonProvider` / `useCommon` — estado común (debug, geo, timezone, actividad de cola/cron).
+- `PlainLayout` / `TabNavigatorLayout` — layouts conectados a react-router.
+- `installGlobalErrorHandler()` — handler global (errores de dominio → Alert).
+
+## Subpaths
+
+Las primitivas y capas se importan por subpath, p. ej.:
+
+```ts
+import { DomainModule } from "@sincpro/mobile/entrypoints/app/domain_module";
+import type { Subscriber } from "@sincpro/mobile/domain/subscriber";
+import { setPrinterDriver } from "@sincpro/mobile/domain/print";
+```
+
+## Impresora (opcional)
+
+El core es agnóstico del hardware: define el puerto `IPrinterDriver` (`@sincpro/mobile/domain/print`). La app registra un driver concreto al bootstrap:
+
+```ts
+import { setPrinterDriver } from "@sincpro/mobile/domain/print";
+setPrinterDriver(miDriver);
+```
+
+## Desarrollo
+
+Todo vía Makefile: `make build` (tsc → `lib/`), `make check` (lint + typecheck), `make format`, `make publish`.

package/dist/adapters/Bluetooth.adapter.d.ts

@@ -0,0 +1,14 @@
+import { BluetoothPermissionStatus, BluetoothStatus } from "../domain/connectivity";
+declare class BluetoothAdapterImpl {
+    requestPermissions(): Promise<BluetoothPermissionStatus>;
+    hasPermissions(): Promise<BluetoothPermissionStatus>;
+    getStatus(): Promise<BluetoothStatus>;
+    isAndroid12OrHigher(): boolean;
+    getPlatform(): "android" | "ios" | "other";
+    private requestAndroidPermissions;
+    private checkAndroidPermissions;
+    private requestIOSPermissions;
+    private checkIOSPermissions;
+}
+export declare const BluetoothAdapter: BluetoothAdapterImpl;
+export {};

package/dist/adapters/Bluetooth.adapter.js

@@ -0,0 +1,100 @@
+import { PermissionsAndroid, Platform } from "react-native";
+const ANDROID_12_API_LEVEL = 31;
+class BluetoothAdapterImpl {
+    async requestPermissions() {
+        if (Platform.OS === "android") {
+            return this.requestAndroidPermissions();
+        }
+        if (Platform.OS === "ios") {
+            return this.requestIOSPermissions();
+        }
+        return { scan: false, connect: false, advertise: false, isGranted: false };
+    }
+    async hasPermissions() {
+        if (Platform.OS === "android") {
+            return this.checkAndroidPermissions();
+        }
+        if (Platform.OS === "ios") {
+            return this.checkIOSPermissions();
+        }
+        return { scan: false, connect: false, advertise: false, isGranted: false };
+    }
+    async getStatus() {
+        const permissions = await this.hasPermissions();
+        const state = permissions.isGranted ? "PoweredOn" : "Unauthorized";
+        return {
+            isEnabled: permissions.isGranted,
+            state,
+            permissions,
+        };
+    }
+    isAndroid12OrHigher() {
+        return Platform.OS === "android" && Platform.Version >= ANDROID_12_API_LEVEL;
+    }
+    getPlatform() {
+        if (Platform.OS === "android")
+            return "android";
+        if (Platform.OS === "ios")
+            return "ios";
+        return "other";
+    }
+    async requestAndroidPermissions() {
+        if (Platform.OS !== "android") {
+            return { scan: true, connect: true, advertise: true, isGranted: true };
+        }
+        if (Platform.Version < ANDROID_12_API_LEVEL) {
+            const locationGranted = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+            const isGranted = locationGranted === PermissionsAndroid.RESULTS.GRANTED;
+            return { scan: isGranted, connect: isGranted, advertise: isGranted, isGranted };
+        }
+        const results = await PermissionsAndroid.requestMultiple([
+            PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+            PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+            PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE,
+        ]);
+        const scan = results[PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] ===
+            PermissionsAndroid.RESULTS.GRANTED;
+        const connect = results[PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] ===
+            PermissionsAndroid.RESULTS.GRANTED;
+        const advertise = results[PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE] ===
+            PermissionsAndroid.RESULTS.GRANTED;
+        return {
+            scan,
+            connect,
+            advertise,
+            isGranted: scan && connect,
+        };
+    }
+    async checkAndroidPermissions() {
+        if (Platform.OS !== "android") {
+            return { scan: true, connect: true, advertise: true, isGranted: true };
+        }
+        if (Platform.Version < ANDROID_12_API_LEVEL) {
+            const locationGranted = await PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+            return {
+                scan: locationGranted,
+                connect: locationGranted,
+                advertise: locationGranted,
+                isGranted: locationGranted,
+            };
+        }
+        const [scan, connect, advertise] = await Promise.all([
+            PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN),
+            PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT),
+            PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.BLUETOOTH_ADVERTISE),
+        ]);
+        return {
+            scan,
+            connect,
+            advertise,
+            isGranted: scan && connect,
+        };
+    }
+    async requestIOSPermissions() {
+        return { scan: true, connect: true, advertise: true, isGranted: true };
+    }
+    async checkIOSPermissions() {
+        return { scan: true, connect: true, advertise: true, isGranted: true };
+    }
+}
+export const BluetoothAdapter = new BluetoothAdapterImpl();

package/dist/adapters/Geo.adapter.d.ts

@@ -0,0 +1,8 @@
+import { Coordinates } from "../domain/connectivity";
+import * as Location from "expo-location";
+export declare const GeoAdapter: {
+    requestPermission(): Promise<boolean>;
+    hasPermission(): Promise<boolean>;
+    getCurrentLocation(): Promise<Coordinates>;
+    watchLocation(onUpdate: (coords: Coordinates) => void): Promise<Location.LocationSubscription>;
+};

package/dist/adapters/Geo.adapter.js

@@ -0,0 +1,30 @@
+import * as Location from "expo-location";
+export const GeoAdapter = {
+    async requestPermission() {
+        const { status } = await Location.requestForegroundPermissionsAsync();
+        return status === Location.PermissionStatus.GRANTED;
+    },
+    async hasPermission() {
+        const { status } = await Location.getForegroundPermissionsAsync();
+        return status === Location.PermissionStatus.GRANTED;
+    },
+    async getCurrentLocation() {
+        const { coords } = await Location.getCurrentPositionAsync({});
+        return {
+            latitude: coords.latitude,
+            longitude: coords.longitude,
+        };
+    },
+    async watchLocation(onUpdate) {
+        return await Location.watchPositionAsync({
+            accuracy: Location.Accuracy.High,
+            timeInterval: 5000,
+            distanceInterval: 10,
+        }, (location) => {
+            onUpdate({
+                latitude: location.coords.latitude,
+                longitude: location.coords.longitude,
+            });
+        });
+    },
+};

package/dist/adapters/JsonSerializer.adapter.d.ts

@@ -0,0 +1,28 @@
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+interface JsonObject {
+    [key: string]: JsonValue;
+}
+type JsonArray = JsonValue[];
+/**
+ * Adapter for generating canonical JSON and SHA-256 hashes
+ * in a deep, deterministic manner without external dependencies.
+ */
+export declare const JsonSerializerAdapter: {
+    /**
+     * Normalize special types (Date, etc.) into JSON-friendly structures.
+     */
+    cleanData<T extends JsonValue>(data: T): JsonValue;
+    /**
+     * Recursively sort object keys and serialize without extra whitespace.
+     */
+    canonicalize(value: JsonValue): string;
+    /**
+     * Convert a RoutePlan object to its canonical JSON string.
+     */
+    convertToCanonicalJson(jsObj: any): string;
+    /**
+     * Compute the SHA-256 hash of the canonical JSON.
+     */
+    calculateHash(jsObj: any): Promise<string>;
+};
+export {};

package/dist/adapters/JsonSerializer.adapter.js

@@ -0,0 +1,47 @@
+import * as Crypto from "expo-crypto";
+/**
+ * Adapter for generating canonical JSON and SHA-256 hashes
+ * in a deep, deterministic manner without external dependencies.
+ */
+export const JsonSerializerAdapter = {
+    /**
+     * Normalize special types (Date, etc.) into JSON-friendly structures.
+     */
+    cleanData(data) {
+        const replacer = (_key, value) => value instanceof Date ? value.toISOString() : value;
+        return JSON.parse(JSON.stringify(data, replacer));
+    },
+    /**
+     * Recursively sort object keys and serialize without extra whitespace.
+     */
+    canonicalize(value) {
+        if (value === null || typeof value !== "object") {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map((v) => this.canonicalize(v)).join(",")}]`;
+        }
+        const obj = value;
+        return ("{" +
+            Object.keys(obj)
+                .sort()
+                .filter((k) => obj[k] !== undefined)
+                .map((k) => `${JSON.stringify(k)}:${this.canonicalize(obj[k])}`)
+                .join(",") +
+            "}");
+    },
+    /**
+     * Convert a RoutePlan object to its canonical JSON string.
+     */
+    convertToCanonicalJson(jsObj) {
+        const clean = this.cleanData(jsObj);
+        return this.canonicalize(clean);
+    },
+    /**
+     * Compute the SHA-256 hash of the canonical JSON.
+     */
+    async calculateHash(jsObj) {
+        const canonical = this.convertToCanonicalJson(jsObj);
+        return Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, canonical);
+    },
+};

package/dist/adapters/Network.adapter.d.ts

@@ -0,0 +1,4 @@
+import { NetworkStatus } from "../domain/connectivity";
+export declare const NetworkAdapter: {
+    getStatus(): Promise<NetworkStatus>;
+};

package/dist/adapters/Network.adapter.js

@@ -0,0 +1,13 @@
+import * as Network from "expo-network";
+export const NetworkAdapter = {
+    async getStatus() {
+        const state = await Network.getNetworkStateAsync();
+        const ip = await Network.getIpAddressAsync();
+        return {
+            isConnected: state.isConnected ?? false,
+            isInternetReachable: state.isInternetReachable ?? null,
+            type: state.type,
+            ipAddress: ip ?? null,
+        };
+    },
+};

package/dist/adapters/ReceiptExporter.adapter.d.ts

@@ -0,0 +1,19 @@
+import { RefObject } from "react";
+import { View } from "react-native";
+interface ExportOptions {
+    fileName?: string;
+    receiptWidthMm?: number;
+    quality?: number;
+    dialogTitle?: string;
+}
+interface ExportResult {
+    success: boolean;
+    fileUri?: string;
+    error?: string;
+}
+export declare const ReceiptExporterAdapter: {
+    captureAndShareAsPdf(viewRef: RefObject<View | null>, options?: ExportOptions): Promise<ExportResult>;
+    captureAsPdf(viewRef: RefObject<View | null>, options?: Omit<ExportOptions, "dialogTitle">): Promise<ExportResult>;
+    captureAsImageBase64(viewRef: RefObject<View | null>, quality?: number): Promise<string | null>;
+};
+export {};

package/dist/adapters/ReceiptExporter.adapter.js

@@ -0,0 +1,142 @@
+import { File, Paths } from "expo-file-system";
+import * as Sharing from "expo-sharing";
+import { PDFDocument } from "pdf-lib";
+import { Platform } from "react-native";
+import { captureRef } from "react-native-view-shot";
+const DEFAULT_CONFIG = {
+    RECEIPT_WIDTH_MM: 72,
+    MM_TO_POINTS: 2.83464567,
+    IMAGE_QUALITY: 0.8,
+};
+function sanitizeFileName(name) {
+    return name.replace(/[^a-zA-Z0-9-_]/g, "_");
+}
+function generateFileName(baseName, extension = "pdf") {
+    const sanitized = sanitizeFileName(baseName || "comprobante");
+    return `${sanitized}_${Date.now()}.${extension}`;
+}
+async function captureViewToTmpFile(viewRef, quality) {
+    const tmpUri = await captureRef(viewRef, {
+        format: "jpg",
+        quality,
+        result: "tmpfile",
+        useRenderInContext: Platform.OS === "ios",
+    });
+    return tmpUri;
+}
+async function readImageAsBase64(tmpUri) {
+    const tmpFile = new File(tmpUri);
+    return await tmpFile.base64();
+}
+async function createPdfFromJpg(jpgBase64, receiptWidthMm) {
+    const pdfDoc = await PDFDocument.create();
+    const jpgImage = await pdfDoc.embedJpg(jpgBase64);
+    const pageWidth = receiptWidthMm * DEFAULT_CONFIG.MM_TO_POINTS;
+    const scale = pageWidth / jpgImage.width;
+    const pageHeight = jpgImage.height * scale;
+    const page = pdfDoc.addPage([pageWidth, pageHeight]);
+    page.drawImage(jpgImage, {
+        x: 0,
+        y: 0,
+        width: pageWidth,
+        height: pageHeight,
+    });
+    return await pdfDoc.saveAsBase64();
+}
+async function savePdfToFile(pdfBase64, fileName) {
+    const file = new File(Paths.document, fileName);
+    await file.write(pdfBase64, { encoding: "base64" });
+    return file.uri;
+}
+async function cleanupTmpFile(tmpUri) {
+    try {
+        const tmpFile = new File(tmpUri);
+        await tmpFile.delete();
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+async function shareFile(fileUri, dialogTitle) {
+    await Sharing.shareAsync(fileUri, {
+        mimeType: "application/pdf",
+        dialogTitle,
+    });
+}
+async function captureViewToBase64(viewRef, quality) {
+    if (!viewRef.current)
+        return null;
+    try {
+        const base64 = await captureRef(viewRef, {
+            format: "png",
+            quality,
+            result: "base64",
+            useRenderInContext: Platform.OS === "ios",
+        });
+        return base64;
+    }
+    catch (error) {
+        console.error("Error capturing view to base64:", error);
+        return null;
+    }
+}
+export const ReceiptExporterAdapter = {
+    async captureAndShareAsPdf(viewRef, options) {
+        if (!viewRef.current) {
+            return { success: false, error: "View reference is not available" };
+        }
+        const quality = options?.quality ?? DEFAULT_CONFIG.IMAGE_QUALITY;
+        const receiptWidthMm = options?.receiptWidthMm ?? DEFAULT_CONFIG.RECEIPT_WIDTH_MM;
+        const fileName = generateFileName(options?.fileName);
+        const dialogTitle = options?.dialogTitle ?? "Compartir comprobante";
+        let tmpUri = null;
+        try {
+            tmpUri = await captureViewToTmpFile(viewRef, quality);
+            const jpgBase64 = await readImageAsBase64(tmpUri);
+            const pdfBase64 = await createPdfFromJpg(jpgBase64, receiptWidthMm);
+            const fileUri = await savePdfToFile(pdfBase64, fileName);
+            await shareFile(fileUri, dialogTitle);
+            return { success: true, fileUri };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error("Error exporting receipt:", errorMessage);
+            return { success: false, error: errorMessage };
+        }
+        finally {
+            if (tmpUri) {
+                await cleanupTmpFile(tmpUri);
+            }
+        }
+    },
+    async captureAsPdf(viewRef, options) {
+        if (!viewRef.current) {
+            return { success: false, error: "View reference is not available" };
+        }
+        const quality = options?.quality ?? DEFAULT_CONFIG.IMAGE_QUALITY;
+        const receiptWidthMm = options?.receiptWidthMm ?? DEFAULT_CONFIG.RECEIPT_WIDTH_MM;
+        const fileName = generateFileName(options?.fileName);
+        let tmpUri = null;
+        try {
+            tmpUri = await captureViewToTmpFile(viewRef, quality);
+            const jpgBase64 = await readImageAsBase64(tmpUri);
+            const pdfBase64 = await createPdfFromJpg(jpgBase64, receiptWidthMm);
+            const fileUri = await savePdfToFile(pdfBase64, fileName);
+            return { success: true, fileUri };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            console.error("Error creating PDF:", errorMessage);
+            return { success: false, error: errorMessage };
+        }
+        finally {
+            if (tmpUri) {
+                await cleanupTmpFile(tmpUri);
+            }
+        }
+    },
+    async captureAsImageBase64(viewRef, quality) {
+        const imageQuality = quality ?? DEFAULT_CONFIG.IMAGE_QUALITY;
+        return captureViewToBase64(viewRef, imageQuality);
+    },
+};

package/dist/adapters/repositories/database_table.repository.d.ts

@@ -0,0 +1,13 @@
+import { EntityCollection, ICriteria } from "../../domain/entity";
+import { ECommonRepository } from "../../domain/repositories";
+declare class DatabaseTableRepositoryImpl {
+    readonly name = ECommonRepository.DATABASE_TABLE;
+    findAll(): Promise<EntityCollection<any>>;
+    getTableData(tableName: string): Promise<any[]>;
+    save(entity: any | any[] | EntityCollection<any>): Promise<void>;
+    remove(entity: any | any[]): Promise<void>;
+    findById(id: number | string): Promise<any | null>;
+    findByCriteria(criteria: ICriteria<any>[]): Promise<EntityCollection<any>>;
+}
+export declare const DatabaseTableRepository: DatabaseTableRepositoryImpl;
+export {};

package/dist/adapters/repositories/database_table.repository.js

@@ -0,0 +1,29 @@
+import { EntityCollection } from "../../domain/entity";
+import { ECommonRepository } from "../../domain/repositories";
+import { DBCursor } from "../../infrastructure/database";
+import logger from "../../infrastructure/logger";
+class DatabaseTableRepositoryImpl {
+    name = ECommonRepository.DATABASE_TABLE;
+    async findAll() {
+        logger.debug("Fetching all database tables");
+        const result = await DBCursor.getAllAsync(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';`);
+        return new EntityCollection((result ?? []));
+    }
+    async getTableData(tableName) {
+        const query = `SELECT * FROM ${tableName};`;
+        return await DBCursor.getAllAsync(query);
+    }
+    async save(entity) {
+        throw new Error("Not implemented");
+    }
+    async remove(entity) {
+        throw new Error("Not implemented");
+    }
+    async findById(id) {
+        throw new Error("Not implemented");
+    }
+    async findByCriteria(criteria) {
+        throw new Error("Not implemented");
+    }
+}
+export const DatabaseTableRepository = new DatabaseTableRepositoryImpl();

package/dist/adapters/repositories/domain_event.repository.d.ts

@@ -0,0 +1,32 @@
+import { DomainEvent, EEventStatus } from "../../domain/event_sourcing";
+import { ECommonRepository } from "../../domain/repositories";
+import { DATABASE_TABLES } from "../../entrypoints/db/migrations";
+declare class DomainEventRepositoryImpl {
+    readonly name = ECommonRepository.DOMAIN_EVENT;
+    readonly table = DATABASE_TABLES.DOMAIN_EVENTS;
+    private hasPendingDuplicate;
+    save(event: DomainEvent): Promise<void>;
+    saveMany(events: DomainEvent[]): Promise<void>;
+    findById(uuid: string): Promise<DomainEvent | null>;
+    findByIds(uuids: string[]): Promise<DomainEvent[]>;
+    findNextPending(internetConnected: boolean): Promise<DomainEvent | null>;
+    findByStatus(status: EEventStatus): Promise<DomainEvent[]>;
+    findByStatuses(statuses: EEventStatus[]): Promise<DomainEvent[]>;
+    findByCorrelationId(correlationId: string): Promise<DomainEvent[]>;
+    findByAggregateId(aggregateId: string): Promise<DomainEvent[]>;
+    findByName(name: string): Promise<DomainEvent[]>;
+    findPending(): Promise<DomainEvent[]>;
+    findFailed(): Promise<DomainEvent[]>;
+    remove(uuid: string): Promise<void>;
+    removeByCorrelationId(correlationId: string): Promise<void>;
+    removeAcknowledged(): Promise<void>;
+    clearAll(): Promise<void>;
+    count(): Promise<number>;
+    countByStatus(status: EEventStatus): Promise<number>;
+    findByIdSync(uuid: string): DomainEvent | null;
+    findByIdsSync(uuids: string[]): DomainEvent[];
+    findByRemoteIdSync(remoteId: number | string): DomainEvent | null;
+    findByRemoteIdsSync(remoteIds: (number | string)[]): DomainEvent[];
+}
+export declare const DomainEventRepository: DomainEventRepositoryImpl;
+export {};