@sincpro/mobile 0.1.0

package/dist/domain/webview/events.js

@@ -0,0 +1,11 @@
+import { DomainEvent } from "../../domain/event_sourcing";
+export class WebViewMessageReceivedEvent extends DomainEvent {
+    static name = "common.webview.v1.message_received";
+    static label = "Procesando datos de la web";
+    static requiresNetwork = false;
+    name = WebViewMessageReceivedEvent.name;
+    label = WebViewMessageReceivedEvent.label;
+    requiresNetwork = WebViewMessageReceivedEvent.requiresNetwork;
+    raw = "";
+    source = "";
+}

package/dist/domain/webview/index.d.ts

@@ -0,0 +1 @@
+export { EWebViewMessageType, type IAjaxInterceptedMessage, type IContentReadyMessage, type IDebugPrintMessage, type IInjectedScript, type IInjectionReadyMessage, type IPrintImageMessage, type IPrintRequestMessage, type IWebViewMetadata, type TPrintSource, type TWebViewMessage, } from "./webview";

package/dist/domain/webview/index.js

@@ -0,0 +1 @@
+export { EWebViewMessageType, } from "./webview";

package/dist/domain/webview/webview.d.ts

@@ -0,0 +1,57 @@
+export declare enum EWebViewMessageType {
+    PRINT_REQUEST = "PRINT_REQUEST",
+    PRINT_IMAGE = "PRINT_IMAGE",
+    CONTENT_READY = "CONTENT_READY",
+    INJECTION_READY = "INJECTION_READY",
+    AJAX_INTERCEPTED = "AJAX_INTERCEPTED",
+    DEBUG_PRINT = "DEBUG_PRINT"
+}
+export type TPrintSource = "pos-receipt" | "report" | "document" | "unknown";
+export interface IWebViewMetadata {
+    url: string;
+    title: string;
+    capturedAt: string;
+}
+export interface IPrintRequestMessage {
+    type: EWebViewMessageType.PRINT_REQUEST;
+    source: TPrintSource;
+    content: string;
+    metadata: IWebViewMetadata;
+}
+export interface IPrintImageMessage {
+    type: EWebViewMessageType.PRINT_IMAGE;
+    image: string;
+    width: number;
+    height: number;
+    metadata: IWebViewMetadata;
+}
+export interface IContentReadyMessage {
+    type: EWebViewMessageType.CONTENT_READY;
+    height: number;
+}
+export interface IInjectionReadyMessage {
+    type: EWebViewMessageType.INJECTION_READY;
+    injector: string;
+}
+export interface IAjaxInterceptedMessage {
+    type: EWebViewMessageType.AJAX_INTERCEPTED;
+    url: string;
+    method: string;
+    response?: unknown;
+}
+export interface IDebugPrintMessage {
+    type: EWebViewMessageType.DEBUG_PRINT;
+    debug: {
+        tagName: string;
+        className: string;
+        id: string;
+        width: number;
+        height: number;
+        isBody: boolean;
+    };
+}
+export type TWebViewMessage = IPrintRequestMessage | IPrintImageMessage | IContentReadyMessage | IInjectionReadyMessage | IAjaxInterceptedMessage | IDebugPrintMessage;
+export interface IInjectedScript {
+    name: string;
+    script: string;
+}

package/dist/domain/webview/webview.js

@@ -0,0 +1,9 @@
+export var EWebViewMessageType;
+(function (EWebViewMessageType) {
+    EWebViewMessageType["PRINT_REQUEST"] = "PRINT_REQUEST";
+    EWebViewMessageType["PRINT_IMAGE"] = "PRINT_IMAGE";
+    EWebViewMessageType["CONTENT_READY"] = "CONTENT_READY";
+    EWebViewMessageType["INJECTION_READY"] = "INJECTION_READY";
+    EWebViewMessageType["AJAX_INTERCEPTED"] = "AJAX_INTERCEPTED";
+    EWebViewMessageType["DEBUG_PRINT"] = "DEBUG_PRINT";
+})(EWebViewMessageType || (EWebViewMessageType = {}));

package/dist/entrypoints/cron/Cron.d.ts

@@ -0,0 +1,13 @@
+import type { CronWorker } from "../../infrastructure/workers";
+export interface SyncResult {
+    changed: boolean;
+    added: number;
+    removed: number;
+}
+declare class Cron {
+    private lastSyncState;
+    private currentCrons;
+    sync(domains: Set<string>, isAuthenticated: boolean, cronsByKey: Record<string, CronWorker[]>): Promise<SyncResult>;
+}
+export declare const cron: Cron;
+export {};

package/dist/entrypoints/cron/Cron.js

@@ -0,0 +1,57 @@
+import { loggerCronJobs } from "../../infrastructure/logger";
+function statesAreEqual(a, b) {
+    if (!a)
+        return false;
+    if (a.isAuthenticated !== b.isAuthenticated)
+        return false;
+    if (a.domains.size !== b.domains.size)
+        return false;
+    for (const domain of a.domains) {
+        if (!b.domains.has(domain))
+            return false;
+    }
+    return true;
+}
+function calculateDesiredCrons(domains, isAuthenticated, cronsByKey) {
+    const desired = new Set();
+    for (const domain of domains) {
+        const domainCrons = cronsByKey[domain] ?? [];
+        for (const cronWorker of domainCrons) {
+            if (isAuthenticated || !cronWorker.requiresAuth) {
+                desired.add(cronWorker);
+            }
+        }
+    }
+    return desired;
+}
+class Cron {
+    lastSyncState = null;
+    currentCrons = new Set();
+    async sync(domains, isAuthenticated, cronsByKey) {
+        const newState = { domains: new Set(domains), isAuthenticated };
+        if (statesAreEqual(this.lastSyncState, newState)) {
+            return { changed: false, added: 0, removed: 0 };
+        }
+        const desired = calculateDesiredCrons(domains, isAuthenticated, cronsByKey);
+        let added = 0;
+        let removed = 0;
+        for (const cronWorker of this.currentCrons) {
+            if (!desired.has(cronWorker)) {
+                await cronWorker.waitForIdle();
+                await cronWorker.unregister();
+                removed++;
+            }
+        }
+        for (const cronWorker of desired) {
+            if (!this.currentCrons.has(cronWorker)) {
+                await cronWorker.start();
+                added++;
+            }
+        }
+        this.currentCrons = desired;
+        this.lastSyncState = newState;
+        loggerCronJobs.info(`Cron.sync: +${added} -${removed} crons (domains=${[...domains].join(",")}, auth=${isAuthenticated})`);
+        return { changed: true, added, removed };
+    }
+}
+export const cron = new Cron();

package/dist/entrypoints/cron/checkNetworkStatus.cron.d.ts

@@ -0,0 +1,3 @@
+import { CronWorker } from "../../infrastructure/workers";
+declare const cronCheckNetworkStatus: CronWorker;
+export default cronCheckNetworkStatus;

package/dist/entrypoints/cron/checkNetworkStatus.cron.js

@@ -0,0 +1,10 @@
+import { loggerCronJobs } from "../../infrastructure/logger";
+import { CronWorker } from "../../infrastructure/workers";
+import { networkUseCases } from "../../services/network.service";
+async function checkNetworkStatus() {
+    loggerCronJobs.info("Checking network status");
+    await networkUseCases.getNetworkStatus();
+    loggerCronJobs.info("Finished checking network status");
+}
+const cronCheckNetworkStatus = new CronWorker("CHECK_NETWORK", checkNetworkStatus, 2.5);
+export default cronCheckNetworkStatus;

package/dist/entrypoints/db/index.d.ts

@@ -0,0 +1,2 @@
+export { repos, RepositoriesContainer } from "./repositories";
+export { ECommonRepository } from "../../domain/repositories";

package/dist/entrypoints/db/index.js

@@ -0,0 +1,2 @@
+export { repos, RepositoriesContainer } from "./repositories";
+export { ECommonRepository } from "../../domain/repositories";

package/dist/entrypoints/db/migrations.d.ts

@@ -0,0 +1,10 @@
+import { IMigration } from "../../domain/database";
+export declare const enum DATABASE_TABLES {
+    SETTINGS = "settings",
+    EVENT_QUEUE = "event_queue",
+    DEAD_LETTER_QUEUE = "dead_letter_queue",
+    DOMAIN_EVENTS = "domain_events",
+    DOMAIN_EVENTS_DEAD_LETTER = "domain_events_dead_letter"
+}
+declare const MIGRATIONS: IMigration[];
+export default MIGRATIONS;

package/dist/entrypoints/db/migrations.js

@@ -0,0 +1,115 @@
+import { DBCursor } from "../../infrastructure/database";
+async function createSettingsTable() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${"settings" /* DATABASE_TABLES.SETTINGS */}(
+      name TEXT PRIMARY KEY NOT NULL,
+      value TEXT NOT NULL,
+      type TEXT NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+}
+async function createDeadLetterQueueTable() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${"dead_letter_queue" /* DATABASE_TABLES.DEAD_LETTER_QUEUE */} (
+      uuid TEXT PRIMARY KEY NOT NULL, -- UUID v7 for chronological ordering
+      name TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      error_message TEXT
+    );
+  `);
+}
+async function createEventQueueTable() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${"event_queue" /* DATABASE_TABLES.EVENT_QUEUE */}(
+      uuid TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      network_event INTEGER DEFAULT 0,
+      aggregate_id TEXT DEFAULT NULL,
+      sequence INTEGER DEFAULT 0,
+      status TEXT NOT NULL DEFAULT 'PENDING',
+      acknowledged_at TEXT DEFAULT NULL,
+      error_message TEXT DEFAULT NULL
+    );
+  `);
+}
+async function createDomainEventsTable() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */} (
+      uuid TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      label TEXT NOT NULL,
+      data TEXT NOT NULL,
+      requires_network INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'PENDING',
+      attempts INTEGER NOT NULL DEFAULT 0,
+      error_message TEXT DEFAULT NULL,
+      acknowledged_at TEXT DEFAULT NULL,
+      failed_at TEXT DEFAULT NULL,
+      aggregate_id TEXT DEFAULT NULL,
+      source_id TEXT DEFAULT NULL,
+      correlation_id TEXT DEFAULT NULL,
+      sequence INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_domain_events_status ON ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */}(status);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_domain_events_correlation ON ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */}(correlation_id);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_domain_events_aggregate ON ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */}(aggregate_id);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_domain_events_name ON ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */}(name);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_domain_events_created ON ${"domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */}(created_at);
+  `);
+}
+async function createDomainEventsDeadLetterTable() {
+    await DBCursor.execAsync(`
+    CREATE TABLE IF NOT EXISTS ${"domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */} (
+      uuid TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      label TEXT NOT NULL,
+      data TEXT NOT NULL,
+      requires_network INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      error_message TEXT DEFAULT NULL,
+      failed_at TEXT NOT NULL,
+      aggregate_id TEXT DEFAULT NULL,
+      source_id TEXT DEFAULT NULL,
+      correlation_id TEXT DEFAULT NULL,
+      sequence INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_dead_letter_correlation ON ${"domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */}(correlation_id);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_dead_letter_name ON ${"domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */}(name);
+  `);
+    await DBCursor.execAsync(`
+    CREATE INDEX IF NOT EXISTS idx_dead_letter_failed ON ${"domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */}(failed_at);
+  `);
+}
+const MIGRATIONS = [
+    { name: "settings" /* DATABASE_TABLES.SETTINGS */, migrationFn: createSettingsTable },
+    { name: "event_queue" /* DATABASE_TABLES.EVENT_QUEUE */, migrationFn: createEventQueueTable },
+    { name: "dead_letter_queue" /* DATABASE_TABLES.DEAD_LETTER_QUEUE */, migrationFn: createDeadLetterQueueTable },
+    { name: "domain_events" /* DATABASE_TABLES.DOMAIN_EVENTS */, migrationFn: createDomainEventsTable },
+    {
+        name: "domain_events_dead_letter" /* DATABASE_TABLES.DOMAIN_EVENTS_DEAD_LETTER */,
+        migrationFn: createDomainEventsDeadLetterTable,
+    },
+];
+export default MIGRATIONS;

package/dist/entrypoints/db/repositories.d.ts

@@ -0,0 +1,8 @@
+import { EntityCollection, RemoteEntityCollection } from "../../domain/entity";
+export declare class RepositoriesContainer {
+    private registry;
+    register(repositories: Record<string, any>): void;
+    get<T = any>(repositoryKey: string): T;
+    resolveRelation(repositoryKey: string, foreignKeyValue: number | string | number[] | string[], remote?: boolean): EntityCollection<any> | RemoteEntityCollection<any> | undefined;
+}
+export declare const repos: RepositoriesContainer;

package/dist/entrypoints/db/repositories.js

@@ -0,0 +1,34 @@
+import { EntityCollection, RemoteEntityCollection } from "../../domain/entity";
+import { DomainAppError } from "../../exceptions";
+import { loggerRepositories } from "../../infrastructure/logger";
+export class RepositoriesContainer {
+    registry = {};
+    register(repositories) {
+        this.registry = { ...this.registry, ...repositories };
+    }
+    get(repositoryKey) {
+        const repo = this.registry[repositoryKey];
+        if (!repo) {
+            throw new DomainAppError(`[RepositoryFacade] Repository not found: ${repositoryKey}`);
+        }
+        return repo;
+    }
+    resolveRelation(repositoryKey, foreignKeyValue, remote = false) {
+        const repo = this.registry[repositoryKey];
+        if (!repo) {
+            loggerRepositories.warn(`[RepositoryFacade] Repository not found: ${repositoryKey}`);
+            return Array.isArray(foreignKeyValue) ? new EntityCollection([]) : undefined;
+        }
+        if (Array.isArray(foreignKeyValue)) {
+            if (remote) {
+                return repo.findByRemoteIdsSync?.(foreignKeyValue) ?? new RemoteEntityCollection([]);
+            }
+            return repo.findByIdsSync?.(foreignKeyValue) ?? new EntityCollection([]);
+        }
+        if (remote) {
+            return repo.findByRemoteIdSync?.(foreignKeyValue) ?? undefined;
+        }
+        return repo.findByIdSync?.(foreignKeyValue) ?? undefined;
+    }
+}
+export const repos = new RepositoriesContainer();

package/dist/entrypoints/queue/QueueProcessor.d.ts

@@ -0,0 +1,12 @@
+import type { Subscriber } from "../../domain/event_sourcing";
+export interface SyncResult {
+    changed: boolean;
+    added: number;
+    removed: number;
+}
+export declare const QueueProcessor: {
+    start: () => void;
+    stop: () => void;
+    clearQueue: () => Promise<void>;
+    sync: (domains: Set<string>, isAuthenticated: boolean, subscribersByKey: Record<string, Subscriber[]>) => Promise<SyncResult>;
+};

package/dist/entrypoints/queue/QueueProcessor.js

@@ -0,0 +1,75 @@
+import { loggerQueueProcessor } from "../../infrastructure/logger";
+import { EventBus } from "../../infrastructure/workers";
+let isRunning = false;
+let lastSyncState = null;
+let currentSubscribers = new Set();
+function statesAreEqual(a, b) {
+    if (!a)
+        return false;
+    if (a.isAuthenticated !== b.isAuthenticated)
+        return false;
+    if (a.domains.size !== b.domains.size)
+        return false;
+    for (const domain of a.domains) {
+        if (!b.domains.has(domain))
+            return false;
+    }
+    return true;
+}
+function calculateDesiredSubscribers(domains, isAuthenticated, subscribersByKey) {
+    const desired = new Set();
+    for (const domain of domains) {
+        const domainSubscribers = subscribersByKey[domain] ?? [];
+        for (const subscriber of domainSubscribers) {
+            if (isAuthenticated || !subscriber.requiresAuth) {
+                desired.add(subscriber);
+            }
+        }
+    }
+    return desired;
+}
+export const QueueProcessor = {
+    start: () => {
+        if (isRunning)
+            return;
+        isRunning = true;
+        EventBus.start();
+        loggerQueueProcessor.info("QueueProcessor started");
+    },
+    stop: () => {
+        EventBus.stop();
+        isRunning = false;
+        loggerQueueProcessor.info("QueueProcessor stopped");
+    },
+    clearQueue: async () => {
+        await EventBus.clearQueue();
+    },
+    sync: async (domains, isAuthenticated, subscribersByKey) => {
+        const newState = { domains: new Set(domains), isAuthenticated };
+        if (statesAreEqual(lastSyncState, newState)) {
+            return { changed: false, added: 0, removed: 0 };
+        }
+        EventBus.stop();
+        await EventBus.waitForIdle();
+        const desired = calculateDesiredSubscribers(domains, isAuthenticated, subscribersByKey);
+        let added = 0;
+        let removed = 0;
+        for (const subscriber of currentSubscribers) {
+            if (!desired.has(subscriber)) {
+                EventBus.off(subscriber);
+                removed++;
+            }
+        }
+        for (const subscriber of desired) {
+            if (!currentSubscribers.has(subscriber)) {
+                EventBus.on(subscriber);
+                added++;
+            }
+        }
+        currentSubscribers = desired;
+        lastSyncState = newState;
+        loggerQueueProcessor.info(`QueueProcessor.sync: +${added} -${removed} subscribers (domains=${[...domains].join(",")}, auth=${isAuthenticated})`);
+        EventBus.start();
+        return { changed: true, added, removed };
+    },
+};

package/dist/entrypoints/queue/activateDomain.subscriber.d.ts

@@ -0,0 +1,7 @@
+import { DomainEvent, Subscriber } from "../../domain/event_sourcing";
+import { ActivateDomainEvent, DeactivateDomainEvent } from "../../domain/events";
+export declare class ActivateDomainSubscriber extends Subscriber {
+    readonly requiresAuth = false;
+    listen: (typeof ActivateDomainEvent | typeof DeactivateDomainEvent)[];
+    process(event: DomainEvent): Promise<void>;
+}

package/dist/entrypoints/queue/activateDomain.subscriber.js

@@ -0,0 +1,15 @@
+import { Subscriber } from "../../domain/event_sourcing";
+import { ActivateDomainEvent, DeactivateDomainEvent } from "../../domain/events";
+import { orchestrator } from "../../framework/orchestrator";
+export class ActivateDomainSubscriber extends Subscriber {
+    requiresAuth = false;
+    listen = [ActivateDomainEvent, DeactivateDomainEvent];
+    async process(event) {
+        if (event.name === ActivateDomainEvent.name) {
+            await orchestrator.enableDomain(event.domain);
+        }
+        else if (event.name === DeactivateDomainEvent.name) {
+            await orchestrator.disableDomain(event.domain);
+        }
+    }
+}

package/dist/entrypoints/queue/newAppSettings.handler.d.ts

@@ -0,0 +1,7 @@
+import { DomainEvent, Subscriber } from "../../domain/event_sourcing";
+import { NewAppSettingsEvent } from "../../domain/events";
+export declare class NewAppSettingsSubscriber extends Subscriber {
+    listen: (typeof NewAppSettingsEvent)[];
+    getEvent(event: DomainEvent): NewAppSettingsEvent;
+    process(event: NewAppSettingsEvent): Promise<void>;
+}

package/dist/entrypoints/queue/newAppSettings.handler.js

@@ -0,0 +1,17 @@
+import { SettingsRepository } from "../../adapters/repositories/setting.repository";
+import { Subscriber } from "../../domain/event_sourcing";
+import { NewAppSettingsEvent } from "../../domain/events";
+import { loggerUseCases } from "../../infrastructure/logger";
+export class NewAppSettingsSubscriber extends Subscriber {
+    listen = [NewAppSettingsEvent];
+    getEvent(event) {
+        return NewAppSettingsEvent.from(event);
+    }
+    async process(event) {
+        loggerUseCases.info(`Setting ${event.settings.length} settings`);
+        for (const setting of event.settings) {
+            await SettingsRepository.saveOneSetting(setting.key, setting.value);
+        }
+        loggerUseCases.info(`${event.settings.length} settings saved successfully`);
+    }
+}

package/dist/entrypoints/queue/printImage.subscriber.d.ts

@@ -0,0 +1,7 @@
+import { Subscriber } from "../../domain/event_sourcing";
+import { PrintImageRequestedEvent } from "../../domain/events";
+export declare class PrintImageSubscriber extends Subscriber {
+    readonly requiresAuth = false;
+    listen: (typeof PrintImageRequestedEvent)[];
+    process(event: PrintImageRequestedEvent): Promise<void>;
+}

package/dist/entrypoints/queue/printImage.subscriber.js

@@ -0,0 +1,14 @@
+import { Subscriber } from "../../domain/event_sourcing";
+import { PrintImageRequestedEvent } from "../../domain/events";
+import { DomainValidationError } from "../../exceptions";
+import { printerService } from "../../services/printer.service";
+export class PrintImageSubscriber extends Subscriber {
+    requiresAuth = false;
+    listen = [PrintImageRequestedEvent];
+    async process(event) {
+        if (!(await printerService.isConnected())) {
+            throw new DomainValidationError("No printer connected");
+        }
+        await printerService.printImageBase64(event.imageBase64);
+    }
+}

package/dist/entrypoints/queue/processWebViewMessage.subscriber.d.ts

@@ -0,0 +1,7 @@
+import { Subscriber } from "../../domain/event_sourcing";
+import { WebViewMessageReceivedEvent } from "../../domain/events";
+export declare class ProcessWebViewMessageSubscriber extends Subscriber {
+    readonly requiresAuth = false;
+    listen: (typeof WebViewMessageReceivedEvent)[];
+    process(event: WebViewMessageReceivedEvent): Promise<void>;
+}

package/dist/entrypoints/queue/processWebViewMessage.subscriber.js

@@ -0,0 +1,23 @@
+import { Subscriber } from "../../domain/event_sourcing";
+import { PrintImageRequestedEvent, WebViewMessageReceivedEvent, } from "../../domain/events";
+import { DomainValidationError } from "../../exceptions";
+import { EventBus } from "../../infrastructure/workers";
+import { webViewService } from "../../services/webview.service";
+export class ProcessWebViewMessageSubscriber extends Subscriber {
+    requiresAuth = false;
+    listen = [WebViewMessageReceivedEvent];
+    async process(event) {
+        const parsed = webViewService.parseMessage(event.raw);
+        if (!parsed) {
+            throw new DomainValidationError("Invalid WebView message format");
+        }
+        if (webViewService.isPrintImage(parsed)) {
+            await EventBus.publishSync(PrintImageRequestedEvent.create({
+                imageBase64: parsed.image,
+                width: parsed.width,
+                height: parsed.height,
+                title: parsed.metadata.title,
+            }));
+        }
+    }
+}

package/dist/entrypoints/ui/AppShell.d.ts

@@ -0,0 +1,15 @@
+import type { DomainModule } from "../../framework/domain_module";
+import { type ThemeTokens } from "@sincpro/mobile-ui/theme";
+import { type ComponentType, type ReactNode } from "react";
+type ProviderComponent = ComponentType<{
+    children: ReactNode;
+}>;
+export interface AppShellConfig {
+    domains: DomainModule[];
+    ui: Record<string, ComponentType>;
+    activeDomain: string;
+    providers?: ProviderComponent[];
+    theme?: ThemeTokens;
+}
+export declare function createAppShell(config: AppShellConfig): ComponentType;
+export {};

package/dist/entrypoints/ui/AppShell.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
+import { createApp } from "../../framework/createApp";
+import { ToastHost } from "../../infrastructure/ui/ToastHost";
+import { setActiveTheme, themeToVars } from "@sincpro/mobile-ui/theme";
+import { useAppFonts } from "@sincpro/mobile-ui/theme/typography";
+import * as SplashScreen from "expo-splash-screen";
+import { vars } from "nativewind";
+import { useEffect, useState } from "react";
+import { View } from "react-native";
+import { GestureHandlerRootView } from "react-native-gesture-handler";
+import { KeyboardProvider } from "react-native-keyboard-controller";
+import { initialWindowMetrics, SafeAreaProvider } from "react-native-safe-area-context";
+import { NativeRouter } from "react-router-native";
+import { CommonProvider } from "./common_provider";
+import { ActiveDomainApp, DomainSwitcherProvider } from "./domain_switcher";
+function withProviders(providers, children) {
+    return providers.reduceRight((acc, Provider) => _jsx(Provider, { children: acc }), children);
+}
+export function createAppShell(config) {
+    const apps = config.domains
+        .filter((module) => Boolean(config.ui[module.key]))
+        .map((module) => ({
+        key: module.key,
+        name: module.name,
+        component: config.ui[module.key],
+    }));
+    const providers = config.providers ?? [];
+    if (config.theme) {
+        setActiveTheme(config.theme);
+    }
+    const themeStyle = config.theme ? vars(themeToVars(config.theme)) : undefined;
+    return function AppShell() {
+        const [isReady, setIsReady] = useState(false);
+        const fontsLoaded = useAppFonts();
+        useEffect(() => {
+            let active = true;
+            createApp({ domains: config.domains }).then(() => {
+                if (active)
+                    setIsReady(true);
+            });
+            return () => {
+                active = false;
+            };
+        }, []);
+        useEffect(() => {
+            SplashScreen.preventAutoHideAsync().catch(() => { });
+        }, []);
+        useEffect(() => {
+            if (fontsLoaded && isReady) {
+                SplashScreen.hideAsync().catch(() => { });
+            }
+        }, [fontsLoaded, isReady]);
+        if (!isReady || !fontsLoaded) {
+            return null;
+        }
+        return (_jsx(GestureHandlerRootView, { style: { flex: 1 }, children: _jsx(View, { className: "flex-1", style: themeStyle, children: _jsx(SafeAreaProvider, { initialMetrics: initialWindowMetrics, children: _jsx(KeyboardProvider, { children: _jsxs(CommonProvider, { children: [withProviders(providers, _jsx(DomainSwitcherProvider, { apps: apps, initialDomain: config.activeDomain, children: _jsx(NativeRouter, { children: _jsx(ActiveDomainApp, {}) }) })), _jsx(ToastHost, {})] }) }) }) }) }));
+    };
+}