@sincpro/mobile 0.1.0

package/dist/ui/screens/dead_letter_queue/dead_letter_queue.context.js

@@ -0,0 +1,166 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { deadLetterQueueUseCases } from "../../../services/dead_letter_queue.service";
+import { createContext, useCallback, useContext, useMemo, useState, } from "react";
+const DeadLetterQueueContext = createContext(null);
+export function DeadLetterQueueProvider({ children }) {
+    const [events, setEvents] = useState([]);
+    const [selectedEvents, setSelectedEvents] = useState(new Set());
+    const [isLoading, setIsLoading] = useState(false);
+    const [isRetrying, setIsRetrying] = useState(false);
+    const [isDeleting, setIsDeleting] = useState(false);
+    const [page, setPage] = useState(1);
+    const [pageSize] = useState(25);
+    const [pagedEvents, setPagedEvents] = useState([]);
+    const [hasMore, setHasMore] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const paginate = useCallback((list, nextPage) => {
+        const slice = list.slice(0, nextPage * pageSize);
+        setPagedEvents(slice);
+        setHasMore(slice.length < list.length);
+        setPage(nextPage);
+    }, [pageSize]);
+    const loadEvents = useCallback(async () => {
+        setIsLoading(true);
+        try {
+            const fetched = await deadLetterQueueUseCases.getFailedEvents();
+            setEvents(fetched);
+            setSelectedEvents(new Set());
+            paginate(fetched, 1);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [paginate]);
+    const retryEvent = useCallback(async (event) => {
+        setIsRetrying(true);
+        try {
+            await deadLetterQueueUseCases.retryFailedEvent(event);
+            await loadEvents();
+        }
+        finally {
+            setIsRetrying(false);
+        }
+    }, [loadEvents]);
+    const loadMore = useCallback(async () => {
+        if (isLoadingMore || isLoading || !hasMore)
+            return;
+        setIsLoadingMore(true);
+        try {
+            paginate(events, page + 1);
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [events, hasMore, isLoading, isLoadingMore, page, paginate]);
+    const retrySelectedEvents = useCallback(async () => {
+        if (selectedEvents.size === 0) {
+            return { success: 0, failed: 0 };
+        }
+        setIsRetrying(true);
+        try {
+            const eventsToRetry = events.filter((event) => selectedEvents.has(event.uuid));
+            const result = await deadLetterQueueUseCases.retryMultipleFailedEvents(eventsToRetry);
+            await loadEvents();
+            return result;
+        }
+        finally {
+            setIsRetrying(false);
+        }
+    }, [events, selectedEvents, loadEvents]);
+    const deleteEvent = useCallback(async (event) => {
+        setIsDeleting(true);
+        try {
+            await deadLetterQueueUseCases.deleteFailedEvent(event);
+            await loadEvents();
+        }
+        finally {
+            setIsDeleting(false);
+        }
+    }, [loadEvents]);
+    const deleteSelectedEvents = useCallback(async () => {
+        if (selectedEvents.size === 0) {
+            return { success: 0, failed: 0 };
+        }
+        setIsDeleting(true);
+        try {
+            const eventsToDelete = events.filter((event) => selectedEvents.has(event.uuid));
+            const result = await deadLetterQueueUseCases.deleteMultipleFailedEvents(eventsToDelete);
+            await loadEvents();
+            return result;
+        }
+        finally {
+            setIsDeleting(false);
+        }
+    }, [events, selectedEvents, loadEvents]);
+    const toggleSelection = useCallback((eventId) => {
+        setSelectedEvents((prev) => {
+            const next = new Set(prev);
+            if (next.has(eventId)) {
+                next.delete(eventId);
+            }
+            else {
+                next.add(eventId);
+            }
+            return next;
+        });
+    }, []);
+    const selectAll = useCallback(() => {
+        setSelectedEvents(new Set(events.map((event) => event.uuid)));
+    }, [events]);
+    const clearSelection = useCallback(() => {
+        setSelectedEvents(new Set());
+    }, []);
+    const enrichedEvents = useMemo(() => {
+        return pagedEvents || [];
+    }, [pagedEvents]);
+    const value = useMemo(() => ({
+        events,
+        enrichedEvents,
+        selectedEvents,
+        isLoading,
+        isRetrying,
+        isDeleting,
+        loadEvents,
+        retryEvent,
+        retrySelectedEvents,
+        deleteEvent,
+        deleteSelectedEvents,
+        toggleSelection,
+        selectAll,
+        clearSelection,
+        // Pagination
+        loadMore,
+        hasMore,
+        page,
+        pageSize,
+        isLoadingMore,
+    }), [
+        events,
+        enrichedEvents,
+        selectedEvents,
+        isLoading,
+        isRetrying,
+        isDeleting,
+        loadEvents,
+        retryEvent,
+        retrySelectedEvents,
+        deleteEvent,
+        deleteSelectedEvents,
+        toggleSelection,
+        selectAll,
+        clearSelection,
+        loadMore,
+        hasMore,
+        page,
+        pageSize,
+        isLoadingMore,
+    ]);
+    return (_jsx(DeadLetterQueueContext.Provider, { value: value, children: children }));
+}
+export function useDeadLetterQueue() {
+    const context = useContext(DeadLetterQueueContext);
+    if (!context) {
+        throw new Error("useDeadLetterQueue must be used within DeadLetterQueueProvider");
+    }
+    return context;
+}

package/dist/ui/screens/dead_letter_queue/dead_letter_queue.list.d.ts

@@ -0,0 +1,2 @@
+declare function DeadLetterQueueList(): import("react/jsx-runtime").JSX.Element;
+export default DeadLetterQueueList;

package/dist/ui/screens/dead_letter_queue/dead_letter_queue.list.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
+import DeadLetterQueueRow from "../../../ui/components/organisms/DeadLetterQueueRow";
+import { ListViewV2 } from "@sincpro/mobile-ui/views/ListViewV2";
+import { useEffect } from "react";
+import { useNavigate } from "react-router-native";
+import { DeadLetterQueueProvider, useDeadLetterQueue } from "./dead_letter_queue.context";
+function DeadLetterQueueScreenComponent() {
+    const navigate = useNavigate();
+    const { enrichedEvents, isLoading, loadEvents, retryEvent } = useDeadLetterQueue();
+    useEffect(() => {
+        loadEvents();
+    }, [loadEvents]);
+    const onBack = () => navigate(-1);
+    return (_jsxs(ListViewV2.Root, { description: "Eventos que no pudieron ser procesados", isLoading: isLoading, items: enrichedEvents, name: "Eventos fallidos", onBack: onBack, onRefresh: loadEvents, children: [_jsx(ListViewV2.Header, { variant: "FLAT_HEADER" /* EVariantScreenHeader.FLAT_HEADER */ }), _jsx(ListViewV2.Content, { children: (event) => (_jsx(DeadLetterQueueRow, { item: event, onRetry: async (evt) => {
+                        await retryEvent(evt);
+                        setTimeout(() => {
+                            void loadEvents();
+                        }, 5000);
+                    } })) })] }));
+}
+function DeadLetterQueueList() {
+    return (_jsx(DeadLetterQueueProvider, { children: _jsx(DeadLetterQueueScreenComponent, {}) }));
+}
+export default DeadLetterQueueList;

package/dist/ui/screens/events/events.context.d.ts

@@ -0,0 +1,25 @@
+import { DomainEvent } from "../../../domain/event_sourcing";
+import { ReactNode } from "react";
+type EventFilter = "ALL" | "FAILED" | "ACKNOWLEDGED" | "PENDING";
+interface IEventsContext {
+    events: DomainEvent[];
+    pagedEvents: DomainEvent[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    isRetrying: boolean;
+    hasMore: boolean;
+    page: number;
+    pageSize: number;
+    filter: EventFilter;
+    setFilter: (filter: EventFilter) => void;
+    loadEvents: () => Promise<void>;
+    refreshEvents: () => Promise<void>;
+    loadMore: () => Promise<void>;
+    retryEvent: (event: DomainEvent) => Promise<void>;
+}
+export declare function EventsProvider({ children, pageSize, }: {
+    children: ReactNode;
+    pageSize?: number;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useEvents(): IEventsContext;
+export {};

package/dist/ui/screens/events/events.context.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { eventService } from "../../../services/event.service";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+const EventsContext = createContext(null);
+export function EventsProvider({ children, pageSize = 25, }) {
+    const [events, setEvents] = useState([]);
+    const [pagedEvents, setPagedEvents] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [isRetrying, setIsRetrying] = useState(false);
+    const [page, setPage] = useState(1);
+    const [hasMore, setHasMore] = useState(false);
+    const [filter, setFilter] = useState("ALL");
+    const filterEvents = useCallback((list, currentFilter) => {
+        if (currentFilter === "ALL")
+            return list;
+        return list.filter((ev) => {
+            if (!ev.status)
+                return false;
+            if (currentFilter === "FAILED")
+                return ev.status === "FAILED";
+            if (currentFilter === "ACKNOWLEDGED")
+                return ev.status === "ACKNOWLEDGED";
+            if (currentFilter === "PENDING")
+                return ev.status === "PENDING";
+            return true;
+        });
+    }, []);
+    const paginate = useCallback((list, nextPage, currentFilter) => {
+        const filtered = filterEvents(list, currentFilter);
+        const slice = filtered.slice(0, nextPage * pageSize);
+        setPagedEvents(slice);
+        setHasMore(slice.length < filtered.length);
+        setPage(nextPage);
+    }, [filterEvents, pageSize]);
+    const loadEvents = useCallback(async () => {
+        setIsLoading(true);
+        try {
+            const fetched = await eventService.listAllEvents();
+            setEvents(fetched);
+            paginate(fetched, 1, filter);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [filter, paginate]);
+    const refreshEvents = useCallback(async () => {
+        await loadEvents();
+    }, [loadEvents]);
+    useEffect(() => {
+        paginate(events, 1, filter);
+    }, [events, filter, paginate]);
+    const loadMore = useCallback(async () => {
+        if (isLoadingMore || isLoading || !hasMore)
+            return;
+        setIsLoadingMore(true);
+        try {
+            paginate(events, page + 1, filter);
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [events, hasMore, isLoading, isLoadingMore, page, paginate, filter]);
+    const retryEvent = useCallback(async (event) => {
+        setIsRetrying(true);
+        try {
+            await eventService.republishSync(event);
+            await refreshEvents();
+        }
+        finally {
+            setIsRetrying(false);
+        }
+    }, [refreshEvents]);
+    const value = useMemo(() => ({
+        events,
+        pagedEvents,
+        isLoading,
+        isLoadingMore,
+        isRetrying,
+        hasMore,
+        page,
+        pageSize,
+        filter,
+        setFilter,
+        loadEvents,
+        refreshEvents,
+        loadMore,
+        retryEvent,
+    }), [
+        events,
+        pagedEvents,
+        isLoading,
+        isLoadingMore,
+        isRetrying,
+        hasMore,
+        page,
+        pageSize,
+        filter,
+        setFilter,
+        loadEvents,
+        refreshEvents,
+        loadMore,
+        retryEvent,
+    ]);
+    return _jsx(EventsContext.Provider, { value: value, children: children });
+}
+export function useEvents() {
+    const context = useContext(EventsContext);
+    if (!context) {
+        throw new Error("useEvents must be used within EventsProvider");
+    }
+    return context;
+}

package/dist/ui/screens/events/events.list.d.ts

@@ -0,0 +1 @@
+export default function EventsScreen(): import("react/jsx-runtime").JSX.Element;

package/dist/ui/screens/events/events.list.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
+import EventRow from "../../../ui/components/organisms/EventRow";
+import { ListViewV2 } from "@sincpro/mobile-ui/views/ListViewV2";
+import { useEffect } from "react";
+import { useNavigate } from "react-router-native";
+import { EventsProvider, useEvents } from "./events.context";
+const FILTER_OPTIONS = [
+    { label: "Todos", value: "ALL" },
+    { label: "Fallidos", value: "FAILED" },
+    { label: "Reconocidos", value: "ACKNOWLEDGED" },
+    { label: "Pendientes", value: "PENDING" },
+];
+function EventsScreenComponent() {
+    const navigate = useNavigate();
+    const { pagedEvents, isLoading, loadEvents, retryEvent, filter, setFilter } = useEvents();
+    useEffect(() => {
+        void loadEvents();
+    }, [loadEvents]);
+    const onBack = () => navigate(-1);
+    return (_jsxs(ListViewV2.Root, { description: "Eventos registrados", isLoading: isLoading, items: pagedEvents, name: "Eventos", onBack: onBack, onRefresh: loadEvents, children: [_jsx(ListViewV2.Header, { variant: "FLAT_HEADER" /* EVariantScreenHeader.FLAT_HEADER */, children: _jsx(ListViewV2.Header.Filters, { children: _jsx(ListViewV2.Header.Filters.Chips, { children: FILTER_OPTIONS.map((option) => (_jsx(ListViewV2.Header.Filters.Chip, { active: filter === option.value, label: option.label, onPress: () => setFilter(option.value) }, option.value))) }) }) }), _jsx(ListViewV2.Content, { children: (event) => (_jsx(EventRow, { item: event, onRetry: async (evt) => {
+                        await retryEvent(evt);
+                    } })) })] }));
+}
+export default function EventsScreen() {
+    return (_jsx(EventsProvider, { children: _jsx(EventsScreenComponent, {}) }));
+}

package/dist/ui/screens/events/index.d.ts

@@ -0,0 +1 @@
+export { default as EventsScreen } from "./events.list";

package/dist/ui/screens/events/index.js

@@ -0,0 +1 @@
+export { default as EventsScreen } from "./events.list";

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

@@ -0,0 +1,3 @@
+export { default as DatabaseList } from "../../ui/screens/database/database.list";
+export { default as DeadLetterQueueList } from "../../ui/screens/dead_letter_queue/dead_letter_queue.list";
+export { default as EventsScreen } from "../../ui/screens/events/events.list";

package/dist/ui/screens/index.js

@@ -0,0 +1,3 @@
+export { default as DatabaseList } from "../../ui/screens/database/database.list";
+export { default as DeadLetterQueueList } from "../../ui/screens/dead_letter_queue/dead_letter_queue.list";
+export { default as EventsScreen } from "../../ui/screens/events/events.list";

package/package.json

@@ -0,0 +1,125 @@
+{
+  "name": "@sincpro/mobile",
+  "version": "0.1.0",
+  "description": "Sincpro Mobile framework core: offline-first infra (DB, queue/events, cron), DDD patterns, adapters, AppShell and module-driven composition for React Native",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "prettier": {
+    "printWidth": 94
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "framework",
+    "ddd",
+    "offline-first",
+    "sincpro"
+  ],
+  "repository": "https://github.com/Sincpro-SRL/sincpro_mobile",
+  "author": "Gutierrez, Andres <andres.gutierrez@sincpro.com.bo>",
+  "license": "MIT",
+  "dependencies": {
+    "async-mutex": "^0.5.0",
+    "big.js": "^7.0.1",
+    "dayjs": "^1.11.18",
+    "mitt": "^3.0.1",
+    "pdf-lib": "^1.17.1",
+    "tailwind-variants": "^3.2.2",
+    "uuid": "^13.0.0"
+  },
+  "peerDependencies": {
+    "expo-background-task": "*",
+    "expo-clipboard": "*",
+    "expo-crypto": "*",
+    "expo-file-system": "*",
+    "expo-linking": "*",
+    "expo-localization": "*",
+    "expo-location": "*",
+    "expo-network": "*",
+    "expo-print": "*",
+    "expo-sharing": "*",
+    "expo-splash-screen": "*",
+    "expo-sqlite": "*",
+    "expo-task-manager": "*",
+    "nativewind": ">=4",
+    "react": "*",
+    "react-native": "*",
+    "react-native-gesture-handler": "*",
+    "react-native-keyboard-controller": "*",
+    "react-native-safe-area-context": "*",
+    "react-native-toast-message": "*",
+    "react-native-view-shot": "*",
+    "react-native-webview": "*",
+    "react-router-native": ">=6",
+    "@sincpro/mobile-ui": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/big.js": "^6.2.2",
+    "@types/react": "~19.1.10",
+    "@types/uuid": "^10.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-expo": "~10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-react": "^7.37.2",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "expo-background-task": "~1.0.10",
+    "expo-clipboard": "~8.0.8",
+    "expo-crypto": "~15.0.9",
+    "expo-file-system": "~19.0.23",
+    "expo-linking": "~8.0.12",
+    "expo-localization": "~17.0.9",
+    "expo-location": "~19.0.8",
+    "expo-network": "~8.0.8",
+    "expo-print": "~15.0.8",
+    "expo-sharing": "~14.0.8",
+    "expo-splash-screen": "~31.0.13",
+    "expo-sqlite": "~16.0.10",
+    "expo-task-manager": "~14.0.9",
+    "nativewind": "^4.0.1",
+    "prettier": "^3.6.2",
+    "react": "19.1.0",
+    "react-native": "0.81.5",
+    "react-native-gesture-handler": "~2.28.0",
+    "react-native-keyboard-controller": "1.18.5",
+    "react-native-reanimated": "~4.1.1",
+    "react-native-safe-area-context": "~5.6.0",
+    "react-native-svg": "15.12.1",
+    "react-native-toast-message": "^2.3.3",
+    "react-native-view-shot": "^4.0.3",
+    "react-native-webview": "13.15.0",
+    "react-router-native": "^6.30.0",
+    "tsc-alias": "^1.8.17",
+    "typescript": "~5.9.2",
+    "@sincpro/mobile-ui": "^0.2.0"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./domain": "./dist/domain/index.js",
+    "./domain/entity": "./dist/domain/entity/index.js",
+    "./domain/event_sourcing": "./dist/domain/event_sourcing/index.js",
+    "./domain/database": "./dist/domain/database/index.js",
+    "./domain/connectivity": "./dist/domain/connectivity/index.js",
+    "./domain/print": "./dist/domain/print/index.js",
+    "./domain/webview": "./dist/domain/webview/index.js",
+    "./entrypoints/db": "./dist/entrypoints/db/index.js",
+    "./infrastructure/database": "./dist/infrastructure/database/index.js",
+    "./infrastructure/workers": "./dist/infrastructure/workers/index.js",
+    "./ui": "./dist/ui/index.js",
+    "./ui/components/atoms": "./dist/ui/components/atoms/index.js",
+    "./ui/components/molecules": "./dist/ui/components/molecules/index.js",
+    "./ui/components/organisms": "./dist/ui/components/organisms/index.js",
+    "./ui/screens": "./dist/ui/screens/index.js",
+    "./ui/screens/events": "./dist/ui/screens/events/index.js",
+    "./*": "./dist/*.js",
+    "./package.json": "./package.json"
+  }
+}