@sincpro/mobile 0.1.0

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

@@ -0,0 +1,35 @@
+import { ReactNode } from "react";
+export interface TimezoneLocale {
+    timezone: string;
+    locale: string;
+}
+interface Activity {
+    id: string;
+    label: string;
+    type: "queue" | "cron";
+    status: "running" | "failed";
+    error?: string;
+    startedAt: number;
+}
+interface ICommonContext {
+    debugMode: boolean;
+    debugModeLoaded: boolean;
+    toggleDebugMode: () => Promise<void>;
+    currentActivity?: Activity;
+    lastError?: Activity;
+    isProcessing: boolean;
+    dismiss: () => void;
+    hasGeoPermission: boolean;
+    geoIsLoading: boolean;
+    geoError: string | null;
+    checkGeoPermission: () => Promise<void>;
+    requestGeoPermission: () => Promise<boolean>;
+    timezone: string | null;
+    updateTimezone: (tz: TimezoneLocale) => Promise<void>;
+}
+interface CommonProviderProps {
+    children: ReactNode;
+}
+export declare function CommonProvider({ children }: CommonProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useCommon(): ICommonContext;
+export {};

package/dist/entrypoints/ui/common_provider.js

@@ -0,0 +1,244 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { GeoAdapter } from "../../adapters/Geo.adapter";
+import { SettingsRepository } from "../../adapters/repositories/setting.repository";
+import { QueueEndEvent, QueueStartEvent } from "../../domain/events";
+import logger, { loggerUseCases } from "../../infrastructure/logger";
+import { UIEventBus } from "../../infrastructure/ui/UIEventBus";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+const DEBUG_MODE_SETTING_KEY = "app.debug_mode";
+const TIMEZONE_SETTING_KEY = "app.timezone";
+const LOCALE_SETTING_KEY = "app.locale";
+const QUEUE_MIN_VISIBLE_MS = 1200;
+const CommonContext = createContext(null);
+export function CommonProvider({ children }) {
+    const [debugMode, setDebugMode] = useState(false);
+    const [debugModeLoaded, setDebugModeLoaded] = useState(false);
+    const [currentActivity, setCurrentActivity] = useState(undefined);
+    const [cronTasks, setCronTasks] = useState(new Map());
+    const [lastError, setLastError] = useState(undefined);
+    const [dismissed, setDismissed] = useState(false);
+    const [hasGeoPermission, setHasGeoPermission] = useState(false);
+    const [geoIsLoading, setGeoIsLoading] = useState(false);
+    const [geoError, setGeoError] = useState(null);
+    const [timezone, setTimezone] = useState(null);
+    const errorTimeoutRef = useRef(null);
+    const queueClearTimeoutRef = useRef(null);
+    useEffect(() => {
+        async function loadDebugMode() {
+            const value = await SettingsRepository.getSettingByName(DEBUG_MODE_SETTING_KEY);
+            setDebugMode(value === true);
+            setDebugModeLoaded(true);
+        }
+        loadDebugMode();
+    }, []);
+    const toggleDebugMode = useCallback(async () => {
+        const newValue = !debugMode;
+        await SettingsRepository.saveOneSetting(DEBUG_MODE_SETTING_KEY, newValue);
+        setDebugMode(newValue);
+    }, [debugMode]);
+    const dismiss = useCallback(() => {
+        setDismissed(true);
+        setLastError(undefined);
+        if (errorTimeoutRef.current) {
+            clearTimeout(errorTimeoutRef.current);
+            errorTimeoutRef.current = null;
+        }
+    }, []);
+    const checkGeoPermission = useCallback(async () => {
+        setGeoIsLoading(true);
+        setGeoError(null);
+        try {
+            const granted = await GeoAdapter.hasPermission();
+            setHasGeoPermission(granted);
+        }
+        catch (error) {
+            setGeoError(error.message);
+            setHasGeoPermission(false);
+        }
+        finally {
+            setGeoIsLoading(false);
+        }
+    }, []);
+    const requestGeoPermission = useCallback(async () => {
+        setGeoIsLoading(true);
+        setGeoError(null);
+        try {
+            const granted = await GeoAdapter.requestPermission();
+            setHasGeoPermission(granted);
+            return granted;
+        }
+        catch (error) {
+            setGeoError(error.message);
+            setHasGeoPermission(false);
+            return false;
+        }
+        finally {
+            setGeoIsLoading(false);
+        }
+    }, []);
+    const updateTimezone = useCallback(async (tz) => {
+        try {
+            await SettingsRepository.saveOneSetting(TIMEZONE_SETTING_KEY, tz.timezone);
+            await SettingsRepository.saveOneSetting(LOCALE_SETTING_KEY, tz.locale);
+            setTimezone(tz.timezone);
+        }
+        catch (error) {
+            logger.warn(error);
+        }
+    }, []);
+    useEffect(() => {
+        async function loadTimezone() {
+            try {
+                const timezoneResult = await SettingsRepository.getSettingByName(TIMEZONE_SETTING_KEY);
+                setTimezone(timezoneResult);
+            }
+            catch (error) {
+                logger.warn("Failed to load timezone", error);
+            }
+        }
+        loadTimezone();
+    }, []);
+    useEffect(() => {
+        loggerUseCases.debug("[CommonProvider] Setting up UIEventBus listeners");
+        function handleQueueStart(payload) {
+            if (!payload || typeof payload !== "object")
+                return;
+            const { event, label } = payload;
+            if (!label)
+                return;
+            setCurrentActivity({
+                id: event,
+                label,
+                type: "queue",
+                status: "running",
+                startedAt: Date.now(),
+            });
+            setDismissed(false);
+        }
+        function handleQueueEnd(payload) {
+            if (!payload || typeof payload !== "object")
+                return;
+            const { event, success = true, error } = payload;
+            setCurrentActivity((current) => {
+                if (current?.id !== event)
+                    return current;
+                if (!success) {
+                    const failedActivity = { ...current, status: "failed", error };
+                    setLastError(failedActivity);
+                    if (errorTimeoutRef.current)
+                        clearTimeout(errorTimeoutRef.current);
+                    errorTimeoutRef.current = setTimeout(() => {
+                        setLastError(undefined);
+                        errorTimeoutRef.current = null;
+                    }, 10000);
+                    return undefined;
+                }
+                // Éxito: mantener visible un mínimo para que la cola sea perceptible
+                // aunque el evento se procese al instante.
+                const remaining = QUEUE_MIN_VISIBLE_MS - (Date.now() - current.startedAt);
+                if (remaining > 0) {
+                    if (queueClearTimeoutRef.current)
+                        clearTimeout(queueClearTimeoutRef.current);
+                    queueClearTimeoutRef.current = setTimeout(() => {
+                        setCurrentActivity((c) => (c?.id === event ? undefined : c));
+                        queueClearTimeoutRef.current = null;
+                    }, remaining);
+                    return current;
+                }
+                return undefined;
+            });
+        }
+        function handleCronStart(payload) {
+            if (!payload || typeof payload !== "object" || !("task" in payload))
+                return;
+            const { task } = payload;
+            setCronTasks((prev) => {
+                const next = new Map(prev);
+                next.set(task, {
+                    id: task,
+                    label: task,
+                    type: "cron",
+                    status: "running",
+                    startedAt: Date.now(),
+                });
+                return next;
+            });
+        }
+        function handleCronEnd(payload) {
+            if (!payload || typeof payload !== "object" || !("task" in payload))
+                return;
+            const { task } = payload;
+            setCronTasks((prev) => {
+                const next = new Map(prev);
+                next.delete(task);
+                return next;
+            });
+        }
+        const unsubscribers = [
+            UIEventBus.on(QueueStartEvent.name, handleQueueStart),
+            UIEventBus.on(QueueEndEvent.name, handleQueueEnd),
+            UIEventBus.on("CRON_START", handleCronStart),
+            UIEventBus.on("CRON_END", handleCronEnd),
+        ];
+        return () => {
+            loggerUseCases.debug("[CommonProvider] Cleaning up UIEventBus listeners");
+            unsubscribers.forEach((unsub) => unsub());
+            if (errorTimeoutRef.current)
+                clearTimeout(errorTimeoutRef.current);
+            if (queueClearTimeoutRef.current)
+                clearTimeout(queueClearTimeoutRef.current);
+        };
+    }, []);
+    const displayActivity = useMemo(() => {
+        if (currentActivity)
+            return currentActivity;
+        const firstCron = cronTasks.values().next().value;
+        if (firstCron)
+            return firstCron;
+        return undefined;
+    }, [currentActivity, cronTasks]);
+    const isProcessing = useMemo(() => {
+        if (dismissed)
+            return false;
+        return !!(currentActivity || cronTasks.size > 0 || lastError);
+    }, [currentActivity, cronTasks, lastError, dismissed]);
+    const value = useMemo(() => ({
+        debugMode,
+        debugModeLoaded,
+        toggleDebugMode,
+        currentActivity: displayActivity,
+        lastError,
+        isProcessing,
+        dismiss,
+        hasGeoPermission,
+        geoIsLoading,
+        geoError,
+        checkGeoPermission,
+        requestGeoPermission,
+        timezone,
+        updateTimezone,
+    }), [
+        debugMode,
+        debugModeLoaded,
+        toggleDebugMode,
+        displayActivity,
+        lastError,
+        isProcessing,
+        dismiss,
+        hasGeoPermission,
+        geoIsLoading,
+        geoError,
+        checkGeoPermission,
+        requestGeoPermission,
+        timezone,
+        updateTimezone,
+    ]);
+    return _jsx(CommonContext.Provider, { value: value, children: children });
+}
+export function useCommon() {
+    const ctx = useContext(CommonContext);
+    if (!ctx) {
+        throw new Error("useCommon must be used within CommonProvider");
+    }
+    return ctx;
+}

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

@@ -0,0 +1,19 @@
+import { type ComponentType, type ReactNode } from "react";
+export interface DomainApp {
+    key: string;
+    name: string;
+    component: ComponentType;
+}
+interface DomainSwitcherValue {
+    activeDomain: string;
+    setActiveDomain: (key: string) => void;
+    apps: DomainApp[];
+}
+export declare function DomainSwitcherProvider(props: {
+    apps: DomainApp[];
+    initialDomain: string;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useDomainSwitcher(): DomainSwitcherValue;
+export declare function ActiveDomainApp(): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/entrypoints/ui/domain_switcher.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { createContext, useContext, useState, } from "react";
+const DomainSwitcherContext = createContext(null);
+export function DomainSwitcherProvider(props) {
+    const [activeDomain, setActiveDomain] = useState(props.initialDomain);
+    return (_jsx(DomainSwitcherContext.Provider, { value: { activeDomain, setActiveDomain, apps: props.apps }, children: props.children }));
+}
+export function useDomainSwitcher() {
+    const context = useContext(DomainSwitcherContext);
+    if (!context) {
+        throw new Error("useDomainSwitcher must be used within AppShell");
+    }
+    return context;
+}
+export function ActiveDomainApp() {
+    const { activeDomain, apps } = useDomainSwitcher();
+    const app = apps.find((entry) => entry.key === activeDomain);
+    if (!app)
+        return null;
+    const Component = app.component;
+    return _jsx(Component, {});
+}

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

@@ -0,0 +1,15 @@
+import { type DeepPartial, type ThemeTokens } from "@sincpro/mobile-ui/theme";
+/**
+ * API simple y extensible para que los clientes definan su theme.
+ * Parte de los defaults del framework y aplica overrides parciales (tipados).
+ *
+ *   createApp({
+ *     theme: createTheme({ primary: "#FF6600", bg: { page: "#141414" } }),
+ *     domains: [...],
+ *   });
+ *
+ * El resultado se inyecta una vez al bootstrap (estático, sin runtime switching)
+ * y propaga tanto a `className` (CSS vars) como a `style={theme.x}`.
+ */
+export declare function createTheme(overrides?: DeepPartial<ThemeTokens>): ThemeTokens;
+export type { DeepPartial, ThemeTokens };

package/dist/entrypoints/ui/theme.js

@@ -0,0 +1,16 @@
+import { extendTheme } from "@sincpro/mobile-ui/theme";
+/**
+ * API simple y extensible para que los clientes definan su theme.
+ * Parte de los defaults del framework y aplica overrides parciales (tipados).
+ *
+ *   createApp({
+ *     theme: createTheme({ primary: "#FF6600", bg: { page: "#141414" } }),
+ *     domains: [...],
+ *   });
+ *
+ * El resultado se inyecta una vez al bootstrap (estático, sin runtime switching)
+ * y propaga tanto a `className` (CSS vars) como a `style={theme.x}`.
+ */
+export function createTheme(overrides) {
+    return extendTheme(overrides);
+}

package/dist/exceptions.d.ts

@@ -0,0 +1,22 @@
+export declare class DomainException extends Error {
+    constructor(message: string);
+}
+export declare class DomainUserError extends DomainException {
+    constructor(message: string);
+}
+export declare class DomainValidationError extends DomainException {
+    constructor(message: string);
+}
+export declare class DomainNetworkError extends DomainException {
+    constructor(message: string);
+}
+export declare class DomainBackendError extends DomainException {
+    constructor(message: string);
+}
+export declare class DomainAppError extends DomainException {
+    constructor(message: string);
+}
+export declare const ValidationError: (message: string) => never;
+export declare const UserError: (message: string) => never;
+export declare const BackendError: (message: string) => never;
+export declare const AppError: (message: string) => never;

package/dist/exceptions.js

@@ -0,0 +1,60 @@
+export class DomainException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DomainException";
+    }
+}
+export class DomainUserError extends DomainException {
+    constructor(message) {
+        super(message);
+        this.name = "UserError";
+    }
+}
+export class DomainValidationError extends DomainException {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+export class DomainNetworkError extends DomainException {
+    constructor(message) {
+        super(message);
+        this.name = "NetworkError";
+    }
+}
+export class DomainBackendError extends DomainException {
+    constructor(message) {
+        super(message);
+        this.name = "BackendError";
+    }
+}
+export class DomainAppError extends DomainException {
+    constructor(message) {
+        super(message);
+        this.name = "AppError";
+    }
+}
+export const ValidationError = (message) => {
+    // setTimeout(() => {
+    //   throw new DomainValidationError(message);
+    // }, 0);
+    throw new DomainValidationError(message);
+};
+export const UserError = (message) => {
+    // setTimeout(() => {
+    //   throw new DomainUserError(message);
+    // }, 0);
+    throw new DomainUserError(message);
+};
+export const BackendError = (message) => {
+    // setTimeout(() => {
+    //   throw new DomainBackendError(message);
+    // }, 0);
+    throw new DomainBackendError(message);
+};
+export const AppError = (message) => {
+    // setTimeout(() => {
+    //   throw new DomainAppError(message);
+    // }, 0);
+    throw new DomainAppError(message);
+};

package/dist/framework/base_module.d.ts

@@ -0,0 +1,14 @@
+import type { IMigration } from "../domain/database";
+import type { Subscriber } from "../domain/event_sourcing";
+import type { CronWorker } from "../infrastructure/workers";
+import { DomainModule } from "./domain_module";
+export declare class BaseModule extends DomainModule {
+    readonly key = "COMMON";
+    readonly name = "Common";
+    readonly shared = true;
+    repositories(): Record<string, object>;
+    migrations(): IMigration[];
+    subscribers(): Subscriber[];
+    crons(): CronWorker[];
+}
+export declare const baseModule: BaseModule;

package/dist/framework/base_module.js

@@ -0,0 +1,40 @@
+import { DatabaseTableRepository } from "../adapters/repositories/database_table.repository";
+import { DomainEventRepository } from "../adapters/repositories/domain_event.repository";
+import { DomainEventDeadLetterRepository } from "../adapters/repositories/domain_event_dead_letter.repository";
+import { SettingsRepository } from "../adapters/repositories/setting.repository";
+import { ECommonRepository } from "../domain/repositories";
+import cronCheckNetworkStatus from "../entrypoints/cron/checkNetworkStatus.cron";
+import MIGRATIONS from "../entrypoints/db/migrations";
+import { ActivateDomainSubscriber } from "../entrypoints/queue/activateDomain.subscriber";
+import { NewAppSettingsSubscriber } from "../entrypoints/queue/newAppSettings.handler";
+import { PrintImageSubscriber } from "../entrypoints/queue/printImage.subscriber";
+import { ProcessWebViewMessageSubscriber } from "../entrypoints/queue/processWebViewMessage.subscriber";
+import { DomainModule } from "./domain_module";
+export class BaseModule extends DomainModule {
+    key = "COMMON";
+    name = "Common";
+    shared = true;
+    repositories() {
+        return {
+            [ECommonRepository.DATABASE_TABLE]: DatabaseTableRepository,
+            [ECommonRepository.DOMAIN_EVENT]: DomainEventRepository,
+            [ECommonRepository.DOMAIN_EVENT_DEAD_LETTER]: DomainEventDeadLetterRepository,
+            [ECommonRepository.SETTINGS]: SettingsRepository,
+        };
+    }
+    migrations() {
+        return MIGRATIONS;
+    }
+    subscribers() {
+        return [
+            new ActivateDomainSubscriber(),
+            new ProcessWebViewMessageSubscriber(),
+            new PrintImageSubscriber(),
+            new NewAppSettingsSubscriber(),
+        ];
+    }
+    crons() {
+        return [cronCheckNetworkStatus];
+    }
+}
+export const baseModule = new BaseModule();

package/dist/framework/createApp.d.ts

@@ -0,0 +1,6 @@
+import type { DomainModule } from "./domain_module";
+import { Kernel } from "./kernel";
+export interface AppConfig {
+    domains?: DomainModule[];
+}
+export declare function createApp(config?: AppConfig): Promise<Kernel>;

package/dist/framework/createApp.js

@@ -0,0 +1,9 @@
+import { baseModule } from "./base_module";
+import { Kernel } from "./kernel";
+import { orchestrator } from "./orchestrator";
+export async function createApp(config = {}) {
+    const kernel = new Kernel([baseModule, ...(config.domains ?? [])]);
+    orchestrator.configure(kernel);
+    await orchestrator.bootstrap();
+    return kernel;
+}

package/dist/framework/domain_module.d.ts

@@ -0,0 +1,13 @@
+import type { IMigration } from "../domain/database";
+import type { Subscriber } from "../domain/event_sourcing";
+import type { CronWorker } from "../infrastructure/workers";
+export declare abstract class DomainModule {
+    abstract readonly key: string;
+    abstract readonly name: string;
+    readonly shared: boolean;
+    repositories(): Record<string, object>;
+    migrations(): IMigration[];
+    subscribers(): Subscriber[];
+    crons(): CronWorker[];
+    persistOnReset(): string[];
+}

package/dist/framework/domain_module.js

@@ -0,0 +1,18 @@
+export class DomainModule {
+    shared = false;
+    repositories() {
+        return {};
+    }
+    migrations() {
+        return [];
+    }
+    subscribers() {
+        return [];
+    }
+    crons() {
+        return [];
+    }
+    persistOnReset() {
+        return [];
+    }
+}

package/dist/framework/kernel.d.ts

@@ -0,0 +1,18 @@
+import type { IMigration } from "../domain/database";
+import type { Subscriber } from "../domain/event_sourcing";
+import type { CronWorker } from "../infrastructure/workers";
+import type { DomainModule } from "./domain_module";
+export declare class Kernel {
+    private readonly modules;
+    constructor(modules: DomainModule[]);
+    keys(): string[];
+    sharedKeys(): string[];
+    repositories(): Record<string, object>;
+    migrations(): IMigration[];
+    persistedTables(): string[];
+    subscribersByKey(): Record<string, Subscriber[]>;
+    cronsByKey(): Record<string, CronWorker[]>;
+    runMigrations(): Promise<void>;
+    bootstrap(): Promise<void>;
+    restartDatabase(): Promise<void>;
+}

package/dist/framework/kernel.js

@@ -0,0 +1,60 @@
+import { repos } from "../entrypoints/db/repositories";
+import { DBCursor } from "../infrastructure/database";
+import { initializeRepositoryFacade } from "../infrastructure/database/mapped";
+import logger, { loggerRepositories } from "../infrastructure/logger";
+export class Kernel {
+    modules;
+    constructor(modules) {
+        this.modules = [...modules].sort((a, b) => Number(b.shared) - Number(a.shared));
+    }
+    keys() {
+        return this.modules.map((module) => module.key);
+    }
+    sharedKeys() {
+        return this.modules.filter((module) => module.shared).map((module) => module.key);
+    }
+    repositories() {
+        return this.modules.reduce((acc, module) => ({ ...acc, ...module.repositories() }), {});
+    }
+    migrations() {
+        return this.modules.flatMap((module) => module.migrations());
+    }
+    persistedTables() {
+        return this.modules.flatMap((module) => module.persistOnReset());
+    }
+    subscribersByKey() {
+        const map = {};
+        for (const module of this.modules) {
+            map[module.key] = module.subscribers();
+        }
+        return map;
+    }
+    cronsByKey() {
+        const map = {};
+        for (const module of this.modules) {
+            map[module.key] = module.crons();
+        }
+        return map;
+    }
+    async runMigrations() {
+        for (const { name, migrationFn } of this.migrations()) {
+            logger.info(`Running migration: ${name}`);
+            await migrationFn();
+        }
+    }
+    async bootstrap() {
+        repos.register(this.repositories());
+        initializeRepositoryFacade(repos);
+        await this.runMigrations();
+    }
+    async restartDatabase() {
+        loggerRepositories.warn("Restarting database");
+        const persisted = this.persistedTables();
+        const tablesToDrop = this.migrations().filter((migration) => !persisted.includes(migration.name));
+        for (const { name } of tablesToDrop) {
+            loggerRepositories.info(`Dropping table: ${name}`);
+            await DBCursor.execAsync(`DROP TABLE IF EXISTS ${name}`);
+        }
+        await this.runMigrations();
+    }
+}

package/dist/framework/orchestrator.d.ts

@@ -0,0 +1,29 @@
+import { AppStateStatus } from "react-native";
+import type { Kernel } from "./kernel";
+type AppStateCallback = (state: AppStateStatus) => void;
+declare class Orchestrator {
+    private kernel;
+    private authenticated;
+    private activeDomains;
+    private sharedKeys;
+    private appStateSubscription;
+    private appStateCallbacks;
+    private mutex;
+    configure(kernel: Kernel): void;
+    private requireKernel;
+    private withMutex;
+    private orchestrateQueue;
+    private orchestrateCron;
+    private restoreConsistency;
+    private initAppStateWatcher;
+    bootstrap(): Promise<void>;
+    authenticateSession(): Promise<void>;
+    restoreSession(): Promise<void>;
+    unauthenticateSession(cleanData?: boolean): Promise<void>;
+    enableDomain(key: string): Promise<void>;
+    disableDomain(key: string): Promise<void>;
+    isSessionAuthenticated(): boolean;
+    subscribeToAppState(callback: AppStateCallback): () => void;
+}
+export declare const orchestrator: Orchestrator;
+export {};