@umituz/react-native-exception 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Ümit UZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,65 @@
+# @umituz/react-native-exception
+
+Exception handling and error tracking for React Native apps.
+
+## Features
+
+- Centralized exception handling
+- Error boundary component
+- Exception store with Zustand
+- Error categorization and severity levels
+- Exception reporting utilities
+
+## Installation
+
+```bash
+npm install @umituz/react-native-exception
+```
+
+## Peer Dependencies
+
+- `react` >= 18.2.0
+- `react-native` >= 0.74.0
+- `zustand` >= 5.0.2
+
+## Usage
+
+### Error Boundary
+
+```typescript
+import { ErrorBoundary } from '@umituz/react-native-exception';
+
+<ErrorBoundary>
+  <YourApp />
+</ErrorBoundary>
+```
+
+### Exception Service
+
+```typescript
+import { exceptionService } from '@umituz/react-native-exception';
+
+try {
+  // Your code
+} catch (error) {
+  exceptionService.handleException(
+    error,
+    'error',
+    'business-logic',
+    { userId: '123' }
+  );
+}
+```
+
+### Exception Store
+
+```typescript
+import { useExceptionStore } from '@umituz/react-native-exception';
+
+const { exceptions, lastError } = useExceptionStore();
+```
+
+## License
+
+MIT
+

package/lib/domain/entities/ExceptionEntity.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Exception Entity - Domain Layer
+ * Pure business logic representation of errors and exceptions
+ */
+export type ExceptionSeverity = 'fatal' | 'error' | 'warning' | 'info';
+export type ExceptionCategory = 'network' | 'validation' | 'authentication' | 'authorization' | 'business-logic' | 'system' | 'storage' | 'unknown';
+export interface ExceptionContext {
+    userId?: string;
+    screen?: string;
+    action?: string;
+    componentStack?: string;
+    metadata?: Record<string, any>;
+}
+export interface ExceptionEntity {
+    id: string;
+    message: string;
+    stack?: string;
+    severity: ExceptionSeverity;
+    category: ExceptionCategory;
+    context: ExceptionContext;
+    timestamp: Date;
+    handled: boolean;
+    reported: boolean;
+}
+export interface ErrorLog {
+    id: string;
+    exceptionId: string;
+    userId?: string;
+    message: string;
+    stack?: string;
+    severity: ExceptionSeverity;
+    category: ExceptionCategory;
+    context: ExceptionContext;
+    createdAt: Date;
+}
+/**
+ * Factory function to create an exception entity
+ */
+export declare function createException(error: Error, severity?: ExceptionSeverity, category?: ExceptionCategory, context?: ExceptionContext): ExceptionEntity;
+/**
+ * Factory function to create an error log
+ */
+export declare function createErrorLog(exception: ExceptionEntity): ErrorLog;
+/**
+ * Determine if exception should be reported
+ */
+export declare function shouldReportException(exception: ExceptionEntity): boolean;

package/lib/domain/entities/ExceptionEntity.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Exception Entity - Domain Layer
+ * Pure business logic representation of errors and exceptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createException = createException;
+exports.createErrorLog = createErrorLog;
+exports.shouldReportException = shouldReportException;
+/**
+ * Factory function to create an exception entity
+ */
+function createException(error, severity = 'error', category = 'unknown', context = {}) {
+    return {
+        id: crypto.randomUUID(),
+        message: error.message,
+        stack: error.stack,
+        severity,
+        category,
+        context,
+        timestamp: new Date(),
+        handled: false,
+        reported: false,
+    };
+}
+/**
+ * Factory function to create an error log
+ */
+function createErrorLog(exception) {
+    return {
+        id: crypto.randomUUID(),
+        exceptionId: exception.id,
+        userId: exception.context.userId,
+        message: exception.message,
+        stack: exception.stack,
+        severity: exception.severity,
+        category: exception.category,
+        context: exception.context,
+        createdAt: new Date(),
+    };
+}
+/**
+ * Determine if exception should be reported
+ */
+function shouldReportException(exception) {
+    // Don't report warnings or info
+    if (exception.severity === 'warning' || exception.severity === 'info') {
+        return false;
+    }
+    // Don't report validation errors (user errors)
+    if (exception.category === 'validation') {
+        return false;
+    }
+    // Report everything else
+    return true;
+}

package/lib/domain/repositories/IExceptionRepository.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Exception Repository Interface
+ * Defines contracts for error logging and reporting
+ */
+import type { ExceptionEntity, ErrorLog } from '../entities/ExceptionEntity';
+export interface ExceptionRepositoryError extends Error {
+    code: 'LOG_FAILED' | 'REPORT_FAILED' | 'FETCH_FAILED';
+}
+export type ExceptionResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ExceptionRepositoryError;
+};
+export interface IExceptionRepository {
+    /**
+     * Log an exception
+     */
+    logException(exception: ExceptionEntity): Promise<ExceptionResult<ErrorLog>>;
+    /**
+     * Report exception to external service (e.g., Sentry)
+     */
+    reportException(exception: ExceptionEntity): Promise<ExceptionResult<boolean>>;
+    /**
+     * Get error logs for a user
+     */
+    getErrorLogs(userId: string, limit?: number): Promise<ExceptionResult<ErrorLog[]>>;
+    /**
+     * Get recent exceptions
+     */
+    getRecentExceptions(limit?: number): Promise<ExceptionResult<ExceptionEntity[]>>;
+    /**
+     * Clear error logs
+     */
+    clearErrorLogs(userId: string): Promise<ExceptionResult<boolean>>;
+}

package/lib/domain/repositories/IExceptionRepository.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Exception Repository Interface
+ * Defines contracts for error logging and reporting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @umituz/react-native-exception - Public API
+ *
+ * Exception handling and error tracking for React Native apps
+ *
+ * Usage:
+ *   import { ErrorBoundary, exceptionService, useExceptionStore } from '@umituz/react-native-exception';
+ */
+export type { ExceptionEntity, ErrorLog, ExceptionContext, ExceptionSeverity, ExceptionCategory, } from './domain/entities/ExceptionEntity';
+export { createException, createErrorLog, shouldReportException, } from './domain/entities/ExceptionEntity';
+export type { IExceptionRepository, ExceptionRepositoryError, ExceptionResult, } from './domain/repositories/IExceptionRepository';
+export { useExceptionStore, useExceptions } from './infrastructure/storage/ExceptionStore';
+export { ExceptionService, exceptionService } from './infrastructure/services/ExceptionService';
+export { ErrorBoundary } from './presentation/components/ErrorBoundary';

package/lib/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @umituz/react-native-exception - Public API
+ *
+ * Exception handling and error tracking for React Native apps
+ *
+ * Usage:
+ *   import { ErrorBoundary, exceptionService, useExceptionStore } from '@umituz/react-native-exception';
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBoundary = exports.exceptionService = exports.ExceptionService = exports.useExceptions = exports.useExceptionStore = exports.shouldReportException = exports.createErrorLog = exports.createException = void 0;
+var ExceptionEntity_1 = require("./domain/entities/ExceptionEntity");
+Object.defineProperty(exports, "createException", { enumerable: true, get: function () { return ExceptionEntity_1.createException; } });
+Object.defineProperty(exports, "createErrorLog", { enumerable: true, get: function () { return ExceptionEntity_1.createErrorLog; } });
+Object.defineProperty(exports, "shouldReportException", { enumerable: true, get: function () { return ExceptionEntity_1.shouldReportException; } });
+// =============================================================================
+// INFRASTRUCTURE LAYER EXPORTS
+// =============================================================================
+// State Store (Zustand)
+var ExceptionStore_1 = require("./infrastructure/storage/ExceptionStore");
+Object.defineProperty(exports, "useExceptionStore", { enumerable: true, get: function () { return ExceptionStore_1.useExceptionStore; } });
+Object.defineProperty(exports, "useExceptions", { enumerable: true, get: function () { return ExceptionStore_1.useExceptions; } });
+// Services
+var ExceptionService_1 = require("./infrastructure/services/ExceptionService");
+Object.defineProperty(exports, "ExceptionService", { enumerable: true, get: function () { return ExceptionService_1.ExceptionService; } });
+Object.defineProperty(exports, "exceptionService", { enumerable: true, get: function () { return ExceptionService_1.exceptionService; } });
+// =============================================================================
+// PRESENTATION LAYER EXPORTS
+// =============================================================================
+// Components
+var ErrorBoundary_1 = require("./presentation/components/ErrorBoundary");
+Object.defineProperty(exports, "ErrorBoundary", { enumerable: true, get: function () { return ErrorBoundary_1.ErrorBoundary; } });

package/lib/infrastructure/services/ExceptionService.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Exception Service - Infrastructure Layer
+ * Centralized exception handling and reporting
+ */
+import type { ExceptionContext, ExceptionSeverity, ExceptionCategory } from '../../domain/entities/ExceptionEntity';
+export declare class ExceptionService {
+    private static instance;
+    private constructor();
+    static getInstance(): ExceptionService;
+    /**
+     * Handle an exception
+     */
+    handleException(error: Error, severity?: ExceptionSeverity, category?: ExceptionCategory, context?: ExceptionContext): void;
+    /**
+     * Report exception to external service (e.g., Sentry)
+     */
+    private reportException;
+    /**
+     * Handle network errors
+     */
+    handleNetworkError(error: Error, context?: ExceptionContext): void;
+    /**
+     * Handle validation errors
+     */
+    handleValidationError(error: Error, context?: ExceptionContext): void;
+    /**
+     * Handle storage/permission errors
+     */
+    handleStorageError(error: Error, context?: ExceptionContext): void;
+    /**
+     * Handle fatal errors
+     */
+    handleFatalError(error: Error, context?: ExceptionContext): void;
+    /**
+     * Clear all exceptions
+     */
+    clearExceptions(): void;
+}
+export declare const exceptionService: ExceptionService;

package/lib/infrastructure/services/ExceptionService.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Exception Service - Infrastructure Layer
+ * Centralized exception handling and reporting
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exceptionService = exports.ExceptionService = void 0;
+const ExceptionEntity_1 = require("../../domain/entities/ExceptionEntity");
+const ExceptionStore_1 = require("../storage/ExceptionStore");
+class ExceptionService {
+    constructor() { }
+    static getInstance() {
+        if (!ExceptionService.instance) {
+            ExceptionService.instance = new ExceptionService();
+        }
+        return ExceptionService.instance;
+    }
+    /**
+     * Handle an exception
+     */
+    handleException(error, severity = 'error', category = 'unknown', context = {}) {
+        const exception = (0, ExceptionEntity_1.createException)(error, severity, category, context);
+        // Add to store
+        ExceptionStore_1.useExceptionStore.getState().addException(exception);
+        // Report to external service if needed
+        if ((0, ExceptionEntity_1.shouldReportException)(exception)) {
+            this.reportException(exception);
+        }
+        // Mark as handled
+        ExceptionStore_1.useExceptionStore.getState().markAsHandled(exception.id);
+    }
+    /**
+     * Report exception to external service (e.g., Sentry)
+     */
+    async reportException(exception) {
+        try {
+            // Mark as reported
+            ExceptionStore_1.useExceptionStore.getState().markAsReported(exception.id);
+        }
+        catch (error) {
+            // Silent failure
+        }
+    }
+    /**
+     * Handle network errors
+     */
+    handleNetworkError(error, context = {}) {
+        this.handleException(error, 'error', 'network', context);
+    }
+    /**
+     * Handle validation errors
+     */
+    handleValidationError(error, context = {}) {
+        this.handleException(error, 'warning', 'validation', context);
+    }
+    /**
+     * Handle storage/permission errors
+     */
+    handleStorageError(error, context = {}) {
+        this.handleException(error, 'error', 'storage', context);
+    }
+    /**
+     * Handle fatal errors
+     */
+    handleFatalError(error, context = {}) {
+        this.handleException(error, 'fatal', 'system', context);
+    }
+    /**
+     * Clear all exceptions
+     */
+    clearExceptions() {
+        ExceptionStore_1.useExceptionStore.getState().clearExceptions();
+    }
+}
+exports.ExceptionService = ExceptionService;
+exports.exceptionService = ExceptionService.getInstance();

package/lib/infrastructure/storage/ExceptionStore.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Exception Store - Zustand State Management
+ * Global exception tracking and error state
+ */
+import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
+interface ExceptionStore {
+    exceptions: ExceptionEntity[];
+    lastError: ExceptionEntity | null;
+    errorCount: number;
+    addException: (exception: ExceptionEntity) => void;
+    markAsHandled: (exceptionId: string) => void;
+    markAsReported: (exceptionId: string) => void;
+    clearExceptions: () => void;
+    getExceptionsByCategory: (category: string) => ExceptionEntity[];
+    getUnhandledExceptions: () => ExceptionEntity[];
+}
+export declare const useExceptionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ExceptionStore>>;
+/**
+ * Hook for accessing exception state
+ */
+export declare const useExceptions: () => {
+    exceptions: ExceptionEntity[];
+    lastError: ExceptionEntity | null;
+    errorCount: number;
+    addException: (exception: ExceptionEntity) => void;
+    markAsHandled: (exceptionId: string) => void;
+    markAsReported: (exceptionId: string) => void;
+    clearExceptions: () => void;
+    getExceptionsByCategory: (category: string) => ExceptionEntity[];
+    getUnhandledExceptions: () => ExceptionEntity[];
+};
+export {};

package/lib/infrastructure/storage/ExceptionStore.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Exception Store - Zustand State Management
+ * Global exception tracking and error state
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useExceptions = exports.useExceptionStore = void 0;
+const zustand_1 = require("zustand");
+exports.useExceptionStore = (0, zustand_1.create)((set, get) => ({
+    exceptions: [],
+    lastError: null,
+    errorCount: 0,
+    addException: (exception) => {
+        const { exceptions } = get();
+        set({
+            exceptions: [exception, ...exceptions].slice(0, 100), // Keep last 100
+            lastError: exception,
+            errorCount: get().errorCount + 1,
+        });
+    },
+    markAsHandled: (exceptionId) => {
+        const { exceptions } = get();
+        const updated = exceptions.map((ex) => ex.id === exceptionId ? { ...ex, handled: true } : ex);
+        set({ exceptions: updated });
+    },
+    markAsReported: (exceptionId) => {
+        const { exceptions } = get();
+        const updated = exceptions.map((ex) => ex.id === exceptionId ? { ...ex, reported: true } : ex);
+        set({ exceptions: updated });
+    },
+    clearExceptions: () => set({ exceptions: [], lastError: null }),
+    getExceptionsByCategory: (category) => {
+        const { exceptions } = get();
+        return exceptions.filter((ex) => ex.category === category);
+    },
+    getUnhandledExceptions: () => {
+        const { exceptions } = get();
+        return exceptions.filter((ex) => !ex.handled);
+    },
+}));
+/**
+ * Hook for accessing exception state
+ */
+const useExceptions = () => {
+    const { exceptions, lastError, errorCount, addException, markAsHandled, markAsReported, clearExceptions, getExceptionsByCategory, getUnhandledExceptions, } = (0, exports.useExceptionStore)();
+    return {
+        exceptions,
+        lastError,
+        errorCount,
+        addException,
+        markAsHandled,
+        markAsReported,
+        clearExceptions,
+        getExceptionsByCategory,
+        getUnhandledExceptions,
+    };
+};
+exports.useExceptions = useExceptions;

package/lib/presentation/components/ErrorBoundary.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Error Boundary Component
+ * Catches React errors and provides fallback UI
+ */
+import React, { Component, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    handleReset: () => void;
+    render(): ReactNode;
+}
+export {};

package/lib/presentation/components/ErrorBoundary.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Error Boundary Component
+ * Catches React errors and provides fallback UI
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBoundary = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const ExceptionService_1 = require("../../infrastructure/services/ExceptionService");
+const react_native_design_system_1 = require("@umituz/react-native-design-system");
+class ErrorBoundary extends react_1.Component {
+    constructor(props) {
+        super(props);
+        this.handleReset = () => {
+            this.setState({
+                hasError: false,
+                error: null,
+            });
+        };
+        this.state = {
+            hasError: false,
+            error: null,
+        };
+    }
+    static getDerivedStateFromError(error) {
+        return {
+            hasError: true,
+            error,
+        };
+    }
+    componentDidCatch(error, errorInfo) {
+        // Log error to exception service
+        ExceptionService_1.exceptionService.handleFatalError(error, {
+            componentStack: errorInfo.componentStack ?? undefined,
+            screen: 'ErrorBoundary',
+        });
+    }
+    render() {
+        if (this.state.hasError) {
+            if (this.props.fallback) {
+                return this.props.fallback;
+            }
+            return (<ErrorDisplay error={this.state.error} onReset={this.handleReset}/>);
+        }
+        return this.props.children;
+    }
+}
+exports.ErrorBoundary = ErrorBoundary;
+const ErrorDisplay = ({ error, onReset }) => {
+    const tokens = (0, react_native_design_system_1.useAppDesignTokens)();
+    const styles = getStyles(tokens);
+    return (<react_native_1.View style={styles.container}>
+      <react_native_1.Text style={styles.title}>Something went wrong</react_native_1.Text>
+      <react_native_1.Text style={styles.message}>
+        {error?.message || 'An unexpected error occurred'}
+      </react_native_1.Text>
+      <react_native_1.TouchableOpacity style={styles.button} onPress={onReset}>
+        <react_native_1.Text style={styles.buttonText}>Try Again</react_native_1.Text>
+      </react_native_1.TouchableOpacity>
+    </react_native_1.View>);
+};
+const getStyles = (tokens) => react_native_1.StyleSheet.create({
+    container: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        padding: tokens.spacing.lg,
+        backgroundColor: tokens.colors.backgroundPrimary,
+    },
+    title: {
+        fontSize: tokens.typography.headlineSmall.fontSize,
+        fontWeight: tokens.typography.headlineSmall.fontWeight,
+        marginBottom: tokens.spacing.sm,
+        color: tokens.colors.textPrimary,
+    },
+    message: {
+        fontSize: tokens.typography.bodyLarge.fontSize,
+        color: tokens.colors.textSecondary,
+        textAlign: 'center',
+        marginBottom: tokens.spacing.lg,
+    },
+    button: {
+        backgroundColor: tokens.colors.primary,
+        paddingHorizontal: tokens.spacing.lg,
+        paddingVertical: tokens.spacing.sm,
+        borderRadius: tokens.borders.radius.sm,
+    },
+    buttonText: {
+        color: tokens.colors.textInverse,
+        fontSize: tokens.typography.bodyLarge.fontSize,
+        fontWeight: tokens.typography.labelLarge.fontWeight,
+    },
+});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@umituz/react-native-exception",
+  "version": "1.0.0",
+  "description": "Exception handling and error tracking for React Native apps",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf lib",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build",
+    "version:patch": "npm version patch -m 'chore: release v%s'",
+    "version:minor": "npm version minor -m 'chore: release v%s'",
+    "version:major": "npm version major -m 'chore: release v%s'"
+  },
+  "keywords": [
+    "react-native",
+    "exception",
+    "error",
+    "error-handling",
+    "error-boundary",
+    "crash-reporting"
+  ],
+  "author": "Ümit UZ <umit@umituz.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umituz/react-native-exception"
+  },
+  "peerDependencies": {
+    "react": ">=18.2.0",
+    "react-native": ">=0.74.0",
+    "zustand": "^5.0.2",
+    "@umituz/react-native-design-system": "^1.8.0"
+  },
+  "peerDependenciesMeta": {
+    "@umituz/react-native-design-system": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/react": "^18.2.45",
+    "@types/react-native": "^0.73.0",
+    "react": "^18.2.0",
+    "react-native": "^0.74.0",
+    "zustand": "^5.0.2",
+    "@umituz/react-native-design-system": "^1.8.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}
+

package/src/domain/entities/ExceptionEntity.ts

@@ -0,0 +1,99 @@
+/**
+ * Exception Entity - Domain Layer
+ * Pure business logic representation of errors and exceptions
+ */
+
+export type ExceptionSeverity = 'fatal' | 'error' | 'warning' | 'info';
+export type ExceptionCategory = 'network' | 'validation' | 'authentication' | 'authorization' | 'business-logic' | 'system' | 'storage' | 'unknown';
+
+export interface ExceptionContext {
+  userId?: string;
+  screen?: string;
+  action?: string;
+  componentStack?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface ExceptionEntity {
+  id: string;
+  message: string;
+  stack?: string;
+  severity: ExceptionSeverity;
+  category: ExceptionCategory;
+  context: ExceptionContext;
+  timestamp: Date;
+  handled: boolean;
+  reported: boolean;
+}
+
+export interface ErrorLog {
+  id: string;
+  exceptionId: string;
+  userId?: string;
+  message: string;
+  stack?: string;
+  severity: ExceptionSeverity;
+  category: ExceptionCategory;
+  context: ExceptionContext;
+  createdAt: Date;
+}
+
+/**
+ * Factory function to create an exception entity
+ */
+export function createException(
+  error: Error,
+  severity: ExceptionSeverity = 'error',
+  category: ExceptionCategory = 'unknown',
+  context: ExceptionContext = {}
+): ExceptionEntity {
+  return {
+    id: crypto.randomUUID(),
+    message: error.message,
+    stack: error.stack,
+    severity,
+    category,
+    context,
+    timestamp: new Date(),
+    handled: false,
+    reported: false,
+  };
+}
+
+/**
+ * Factory function to create an error log
+ */
+export function createErrorLog(
+  exception: ExceptionEntity
+): ErrorLog {
+  return {
+    id: crypto.randomUUID(),
+    exceptionId: exception.id,
+    userId: exception.context.userId,
+    message: exception.message,
+    stack: exception.stack,
+    severity: exception.severity,
+    category: exception.category,
+    context: exception.context,
+    createdAt: new Date(),
+  };
+}
+
+/**
+ * Determine if exception should be reported
+ */
+export function shouldReportException(exception: ExceptionEntity): boolean {
+  // Don't report warnings or info
+  if (exception.severity === 'warning' || exception.severity === 'info') {
+    return false;
+  }
+
+  // Don't report validation errors (user errors)
+  if (exception.category === 'validation') {
+    return false;
+  }
+
+  // Report everything else
+  return true;
+}
+

package/src/domain/repositories/IExceptionRepository.ts

@@ -0,0 +1,46 @@
+/**
+ * Exception Repository Interface
+ * Defines contracts for error logging and reporting
+ */
+
+import type { ExceptionEntity, ErrorLog } from '../entities/ExceptionEntity';
+
+export interface ExceptionRepositoryError extends Error {
+  code: 'LOG_FAILED' | 'REPORT_FAILED' | 'FETCH_FAILED';
+}
+
+export type ExceptionResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: ExceptionRepositoryError;
+};
+
+export interface IExceptionRepository {
+  /**
+   * Log an exception
+   */
+  logException(exception: ExceptionEntity): Promise<ExceptionResult<ErrorLog>>;
+
+  /**
+   * Report exception to external service (e.g., Sentry)
+   */
+  reportException(exception: ExceptionEntity): Promise<ExceptionResult<boolean>>;
+
+  /**
+   * Get error logs for a user
+   */
+  getErrorLogs(userId: string, limit?: number): Promise<ExceptionResult<ErrorLog[]>>;
+
+  /**
+   * Get recent exceptions
+   */
+  getRecentExceptions(limit?: number): Promise<ExceptionResult<ExceptionEntity[]>>;
+
+  /**
+   * Clear error logs
+   */
+  clearErrorLogs(userId: string): Promise<ExceptionResult<boolean>>;
+}
+

package/src/index.ts

@@ -0,0 +1,51 @@
+/**
+ * @umituz/react-native-exception - Public API
+ *
+ * Exception handling and error tracking for React Native apps
+ *
+ * Usage:
+ *   import { ErrorBoundary, exceptionService, useExceptionStore } from '@umituz/react-native-exception';
+ */
+
+// =============================================================================
+// DOMAIN LAYER EXPORTS
+// =============================================================================
+
+// Entities
+export type {
+  ExceptionEntity,
+  ErrorLog,
+  ExceptionContext,
+  ExceptionSeverity,
+  ExceptionCategory,
+} from './domain/entities/ExceptionEntity';
+export {
+  createException,
+  createErrorLog,
+  shouldReportException,
+} from './domain/entities/ExceptionEntity';
+
+// Repositories
+export type {
+  IExceptionRepository,
+  ExceptionRepositoryError,
+  ExceptionResult,
+} from './domain/repositories/IExceptionRepository';
+
+// =============================================================================
+// INFRASTRUCTURE LAYER EXPORTS
+// =============================================================================
+
+// State Store (Zustand)
+export { useExceptionStore, useExceptions } from './infrastructure/storage/ExceptionStore';
+
+// Services
+export { ExceptionService, exceptionService } from './infrastructure/services/ExceptionService';
+
+// =============================================================================
+// PRESENTATION LAYER EXPORTS
+// =============================================================================
+
+// Components
+export { ErrorBoundary } from './presentation/components/ErrorBoundary';
+

package/src/infrastructure/services/ExceptionService.ts

@@ -0,0 +1,102 @@
+/**
+ * Exception Service - Infrastructure Layer
+ * Centralized exception handling and reporting
+ */
+
+import type {
+  ExceptionEntity,
+  ExceptionContext,
+  ExceptionSeverity,
+  ExceptionCategory,
+} from '../../domain/entities/ExceptionEntity';
+import {
+  createException,
+  shouldReportException,
+} from '../../domain/entities/ExceptionEntity';
+import { useExceptionStore } from '../storage/ExceptionStore';
+
+export class ExceptionService {
+  private static instance: ExceptionService;
+
+  private constructor() {}
+
+  static getInstance(): ExceptionService {
+    if (!ExceptionService.instance) {
+      ExceptionService.instance = new ExceptionService();
+    }
+    return ExceptionService.instance;
+  }
+
+  /**
+   * Handle an exception
+   */
+  handleException(
+    error: Error,
+    severity: ExceptionSeverity = 'error',
+    category: ExceptionCategory = 'unknown',
+    context: ExceptionContext = {},
+  ): void {
+    const exception = createException(error, severity, category, context);
+
+    // Add to store
+    useExceptionStore.getState().addException(exception);
+
+    // Report to external service if needed
+    if (shouldReportException(exception)) {
+      this.reportException(exception);
+    }
+
+    // Mark as handled
+    useExceptionStore.getState().markAsHandled(exception.id);
+  }
+
+  /**
+   * Report exception to external service (e.g., Sentry)
+   */
+  private async reportException(exception: ExceptionEntity): Promise<void> {
+    try {
+      // Mark as reported
+      useExceptionStore.getState().markAsReported(exception.id);
+    } catch (error) {
+      // Silent failure
+    }
+  }
+
+  /**
+   * Handle network errors
+   */
+  handleNetworkError(error: Error, context: ExceptionContext = {}): void {
+    this.handleException(error, 'error', 'network', context);
+  }
+
+  /**
+   * Handle validation errors
+   */
+  handleValidationError(error: Error, context: ExceptionContext = {}): void {
+    this.handleException(error, 'warning', 'validation', context);
+  }
+
+  /**
+   * Handle storage/permission errors
+   */
+  handleStorageError(error: Error, context: ExceptionContext = {}): void {
+    this.handleException(error, 'error', 'storage', context);
+  }
+
+  /**
+   * Handle fatal errors
+   */
+  handleFatalError(error: Error, context: ExceptionContext = {}): void {
+    this.handleException(error, 'fatal', 'system', context);
+  }
+
+  /**
+   * Clear all exceptions
+   */
+  clearExceptions(): void {
+    useExceptionStore.getState().clearExceptions();
+  }
+}
+
+export const exceptionService = ExceptionService.getInstance();
+

package/src/infrastructure/storage/ExceptionStore.ts

@@ -0,0 +1,95 @@
+/**
+ * Exception Store - Zustand State Management
+ * Global exception tracking and error state
+ */
+
+import { create } from 'zustand';
+import type { ExceptionEntity } from '../../domain/entities/ExceptionEntity';
+
+interface ExceptionStore {
+  // State
+  exceptions: ExceptionEntity[];
+  lastError: ExceptionEntity | null;
+  errorCount: number;
+
+  // Actions
+  addException: (exception: ExceptionEntity) => void;
+  markAsHandled: (exceptionId: string) => void;
+  markAsReported: (exceptionId: string) => void;
+  clearExceptions: () => void;
+  getExceptionsByCategory: (category: string) => ExceptionEntity[];
+  getUnhandledExceptions: () => ExceptionEntity[];
+}
+
+export const useExceptionStore = create<ExceptionStore>((set, get) => ({
+  exceptions: [],
+  lastError: null,
+  errorCount: 0,
+
+  addException: (exception) => {
+    const { exceptions } = get();
+    set({
+      exceptions: [exception, ...exceptions].slice(0, 100), // Keep last 100
+      lastError: exception,
+      errorCount: get().errorCount + 1,
+    });
+  },
+
+  markAsHandled: (exceptionId) => {
+    const { exceptions } = get();
+    const updated = exceptions.map((ex) =>
+      ex.id === exceptionId ? { ...ex, handled: true } : ex
+    );
+    set({ exceptions: updated });
+  },
+
+  markAsReported: (exceptionId) => {
+    const { exceptions } = get();
+    const updated = exceptions.map((ex) =>
+      ex.id === exceptionId ? { ...ex, reported: true } : ex
+    );
+    set({ exceptions: updated });
+  },
+
+  clearExceptions: () => set({ exceptions: [], lastError: null }),
+
+  getExceptionsByCategory: (category) => {
+    const { exceptions } = get();
+    return exceptions.filter((ex) => ex.category === category);
+  },
+
+  getUnhandledExceptions: () => {
+    const { exceptions } = get();
+    return exceptions.filter((ex) => !ex.handled);
+  },
+}));
+
+/**
+ * Hook for accessing exception state
+ */
+export const useExceptions = () => {
+  const {
+    exceptions,
+    lastError,
+    errorCount,
+    addException,
+    markAsHandled,
+    markAsReported,
+    clearExceptions,
+    getExceptionsByCategory,
+    getUnhandledExceptions,
+  } = useExceptionStore();
+
+  return {
+    exceptions,
+    lastError,
+    errorCount,
+    addException,
+    markAsHandled,
+    markAsReported,
+    clearExceptions,
+    getExceptionsByCategory,
+    getUnhandledExceptions,
+  };
+};
+

package/src/presentation/components/ErrorBoundary.tsx

@@ -0,0 +1,122 @@
+/**
+ * Error Boundary Component
+ * Catches React errors and provides fallback UI
+ */
+
+import React, { Component, ReactNode } from 'react';
+import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
+import { exceptionService } from '../../infrastructure/services/ExceptionService';
+import { useAppDesignTokens } from '@umituz/react-native-design-system';
+
+interface Props {
+  children: ReactNode;
+  fallback?: ReactNode;
+}
+
+interface State {
+  hasError: boolean;
+  error: Error | null;
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = {
+      hasError: false,
+      error: null,
+    };
+  }
+
+  static getDerivedStateFromError(error: Error): State {
+    return {
+      hasError: true,
+      error,
+    };
+  }
+
+  componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void {
+    // Log error to exception service
+    exceptionService.handleFatalError(error, {
+      componentStack: errorInfo.componentStack ?? undefined,
+      screen: 'ErrorBoundary',
+    });
+  }
+
+  handleReset = (): void => {
+    this.setState({
+      hasError: false,
+      error: null,
+    });
+  };
+
+  render(): ReactNode {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+
+      return (
+        <ErrorDisplay error={this.state.error} onReset={this.handleReset} />
+      );
+    }
+
+    return this.props.children;
+  }
+}
+
+interface ErrorDisplayProps {
+  error: Error | null;
+  onReset: () => void;
+}
+
+const ErrorDisplay: React.FC<ErrorDisplayProps> = ({ error, onReset }) => {
+  const tokens = useAppDesignTokens();
+  const styles = getStyles(tokens);
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>Something went wrong</Text>
+      <Text style={styles.message}>
+        {error?.message || 'An unexpected error occurred'}
+      </Text>
+      <TouchableOpacity style={styles.button} onPress={onReset}>
+        <Text style={styles.buttonText}>Try Again</Text>
+      </TouchableOpacity>
+    </View>
+  );
+};
+
+const getStyles = (tokens: ReturnType<typeof useAppDesignTokens>) =>
+  StyleSheet.create({
+    container: {
+      flex: 1,
+      justifyContent: 'center',
+      alignItems: 'center',
+      padding: tokens.spacing.lg,
+      backgroundColor: tokens.colors.backgroundPrimary,
+    },
+    title: {
+      fontSize: tokens.typography.headlineSmall.fontSize,
+      fontWeight: tokens.typography.headlineSmall.fontWeight,
+      marginBottom: tokens.spacing.sm,
+      color: tokens.colors.textPrimary,
+    },
+    message: {
+      fontSize: tokens.typography.bodyLarge.fontSize,
+      color: tokens.colors.textSecondary,
+      textAlign: 'center',
+      marginBottom: tokens.spacing.lg,
+    },
+    button: {
+      backgroundColor: tokens.colors.primary,
+      paddingHorizontal: tokens.spacing.lg,
+      paddingVertical: tokens.spacing.sm,
+      borderRadius: tokens.borders.radius.sm,
+    },
+    buttonText: {
+      color: tokens.colors.textInverse,
+      fontSize: tokens.typography.bodyLarge.fontSize,
+      fontWeight: tokens.typography.labelLarge.fontWeight,
+    },
+  });
+