@unvired/react-native-unvired-sdk 0.0.4

package/BuildNo.txt

@@ -0,0 +1 @@
+R-0.000.0004

package/README.md

@@ -0,0 +1,331 @@
+# React Native Unvired SDK
+
+A comprehensive SDK for React Native applications with support for logging, database operations, notifications, and file system management.
+
+## Installation
+
+```bash
+npm install react-native-unvired-sdk
+# or
+yarn add react-native-unvired-sdk
+```
+
+### Optional Dependencies
+
+The **logger works out of the box** with zero dependencies. For additional features, install the packages you need:
+
+```bash
+# For file operations
+npm install react-native-fs
+
+# For database (choose one)
+npm install react-native-sqlite-storage  # SQL database
+npm install @react-native-async-storage/async-storage  # Simple key-value
+
+# For notifications
+npm install @notifee/react-native
+```
+
+> **See [NPM_PACKAGES.md](./NPM_PACKAGES.md) for detailed package information and implementation guide.**
+
+## Features
+
+- 📝 **Logger** - Comprehensive logging with multiple log levels ✅ **No dependencies**
+- 💾 **Database** - Database operations and data persistence ⚠️ *Requires optional package*
+- 🔔 **Notifications** - Push and local notification management ⚠️ *Requires optional package*
+- 📁 **File System** - File read/write and management operations ⚠️ *Requires optional package*
+- 🔌 **PlatformInterface** - Compatible with PlatformInterface pattern for cross-platform logging
+
+## Usage
+
+### Basic Initialization
+
+```javascript
+import UnviredSDK, { LogLevel } from 'react-native-unvired-sdk';
+
+// Initialize the SDK with all modules
+await UnviredSDK.initialize({
+  logLevel: LogLevel.DEBUG,
+  tag: 'MyApp',
+  database: {
+    // Database configuration
+  },
+  notifications: {
+    // Notification configuration
+  },
+  fileSystem: {
+    basePath: '/path/to/files'
+  }
+});
+```
+
+### Using the Logger
+
+```javascript
+import { logger, LogLevel } from 'react-native-unvired-sdk';
+
+// Set log level
+logger.setLogLevel(LogLevel.DEBUG);
+
+// Log messages
+logger.debug('Debug message');
+logger.info('Info message');
+logger.warn('Warning message');
+logger.error('Error message');
+
+// Create child logger for specific modules
+const childLogger = logger.createChild('FeatureModule');
+childLogger.info('This is from a child logger');
+```
+
+### Using PlatformInterface Pattern
+
+```javascript
+import { logger } from 'react-native-unvired-sdk';
+
+// Use with className and methodName (PlatformInterface compatible)
+logger.logInfo('UserService', 'login', 'User login attempt');
+logger.logError('UserService', 'login', 'Login failed');
+logger.logDebug('UserService', 'fetchProfile', 'Fetching user profile');
+
+// Set log level (accepts string)
+logger.setLogLevel('DEBUG');
+
+// File-based logging
+const logs = await logger.getLogFileContent();
+const backupLogs = await logger.getBackupLogFileContent();
+await logger.clearLogFile();
+```
+
+### Database Operations
+
+```javascript
+import { database } from 'react-native-unvired-sdk';
+
+// Initialize database (if not done in SDK initialization)
+await database.initialize({ /* config */ });
+
+// Insert or update data
+await database.upsert('users', {
+  id: 1,
+  name: 'John Doe',
+  email: 'john@example.com'
+});
+
+// Query data
+const users = await database.query('users', { 
+  where: { active: true } 
+});
+
+// Delete data
+await database.delete('users', { id: 1 });
+
+// Execute transaction
+await database.transaction(async (db) => {
+  await db.upsert('users', userData);
+  await db.upsert('profiles', profileData);
+});
+
+// Clear all data
+await database.clear();
+
+// Close database
+await database.close();
+```
+
+### Notifications
+
+```javascript
+import { notificationManager } from 'react-native-unvired-sdk';
+
+// Initialize notifications (if not done in SDK initialization)
+await notificationManager.initialize({ /* config */ });
+
+// Request permissions
+const granted = await notificationManager.requestPermissions();
+
+// Show a notification
+await notificationManager.showNotification({
+  title: 'Hello',
+  body: 'This is a notification',
+  data: { customData: 'value' }
+});
+
+// Schedule a notification
+const notificationId = await notificationManager.scheduleNotification(
+  {
+    title: 'Reminder',
+    body: 'Don\'t forget!'
+  },
+  new Date(Date.now() + 3600000) // 1 hour from now
+);
+
+// Cancel a notification
+await notificationManager.cancelNotification(notificationId);
+
+// Listen for notification events
+const unsubscribe = notificationManager.on('onNotificationReceived', (notification) => {
+  console.log('Notification received:', notification);
+});
+
+// Set badge count
+await notificationManager.setBadgeCount(5);
+
+// Get badge count
+const count = await notificationManager.getBadgeCount();
+```
+
+### File System Operations
+
+```javascript
+import { fileManager } from 'react-native-unvired-sdk';
+
+// Initialize file manager (if not done in SDK initialization)
+await fileManager.initialize({ basePath: '/path/to/files' });
+
+// Read a file
+const content = await fileManager.readFile('data.txt');
+
+// Write to a file
+await fileManager.writeFile('data.txt', 'Hello World');
+
+// Append to a file
+await fileManager.appendFile('log.txt', 'New log entry\n');
+
+// Check if file exists
+const exists = await fileManager.exists('data.txt');
+
+// Delete a file
+await fileManager.deleteFile('old-file.txt');
+
+// Create directory
+await fileManager.createDirectory('my-folder');
+
+// List files in directory
+const files = await fileManager.listFiles('my-folder');
+
+// Copy file
+await fileManager.copyFile('source.txt', 'destination.txt');
+
+// Move file
+await fileManager.moveFile('old-location.txt', 'new-location.txt');
+
+// Download file
+await fileManager.downloadFile(
+  'https://example.com/file.pdf',
+  'downloads/file.pdf',
+  (progress) => console.log(`Downloaded: ${progress}%`)
+);
+
+// Upload file
+await fileManager.uploadFile(
+  'local-file.jpg',
+  'https://example.com/upload',
+  { headers: { 'Authorization': 'Bearer token' } },
+  (progress) => console.log(`Uploaded: ${progress}%`)
+);
+
+// Get file info
+const info = await fileManager.getFileInfo('data.txt');
+console.log(info.size, info.modifiedTime);
+```
+
+### SDK Shutdown
+
+```javascript
+// Properly shutdown SDK and cleanup resources
+await UnviredSDK.shutdown();
+```
+
+## API Reference
+
+### Log Levels
+
+- `LogLevel.DEBUG` - Detailed debugging information
+- `LogLevel.INFO` - General informational messages
+- `LogLevel.WARN` - Warning messages
+- `LogLevel.ERROR` - Error messages
+- `LogLevel.NONE` - Disable all logging
+
+### Logger Methods
+
+- `logger.debug(message, ...args)` - Log debug message
+- `logger.info(message, ...args)` - Log info message
+- `logger.warn(message, ...args)` - Log warning message
+- `logger.error(message, ...args)` - Log error message
+- `logger.setLogLevel(level)` - Set minimum log level
+- `logger.setTag(tag)` - Set custom tag
+- `logger.createChild(childTag)` - Create child logger with custom tag
+
+### Database Methods
+
+- `database.initialize(config)` - Initialize database
+- `database.upsert(table, data)` - Insert or update data
+- `database.query(table, query)` - Query data
+- `database.delete(table, query)` - Delete data
+- `database.transaction(callback)` - Execute transaction
+- `database.clear()` - Clear all data
+- `database.close()` - Close database connection
+
+### Notification Methods
+
+- `notificationManager.initialize(config)` - Initialize notifications
+- `notificationManager.requestPermissions()` - Request notification permissions
+- `notificationManager.showNotification(notification)` - Show notification
+- `notificationManager.scheduleNotification(notification, time)` - Schedule notification
+- `notificationManager.cancelNotification(id)` - Cancel notification
+- `notificationManager.cancelAllNotifications()` - Cancel all notifications
+- `notificationManager.on(event, handler)` - Register event handler
+- `notificationManager.setBadgeCount(count)` - Set badge count
+- `notificationManager.getBadgeCount()` - Get badge count
+
+### File System Methods
+
+- `fileManager.initialize(config)` - Initialize file manager
+- `fileManager.readFile(path, encoding)` - Read file
+- `fileManager.writeFile(path, content, encoding)` - Write file
+- `fileManager.appendFile(path, content, encoding)` - Append to file
+- `fileManager.deleteFile(path)` - Delete file
+- `fileManager.exists(path)` - Check if file exists
+- `fileManager.createDirectory(path)` - Create directory
+- `fileManager.listFiles(path)` - List files in directory
+- `fileManager.copyFile(source, dest)` - Copy file
+- `fileManager.moveFile(source, dest)` - Move file
+- `fileManager.downloadFile(url, path, onProgress)` - Download file
+- `fileManager.uploadFile(path, url, options, onProgress)` - Upload file
+- `fileManager.getFileInfo(path)` - Get file information
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+```
+
+## Architecture
+
+The SDK is organized into modular components:
+
+```
+src/
+├── logger/          # Logging utilities
+├── database/        # Database operations
+├── notifications/   # Notification management
+├── fileSystem/      # File system operations
+└── index.js         # Main SDK entry point
+```
+
+Each module can be initialized independently or as part of the main SDK initialization.
+
+## License
+
+MIT

package/build.xml

@@ -0,0 +1,103 @@
+<project name="react-native-unvired-sdk" default="npmpublish" basedir="." xmlns:ivy="antlib:org.apache.ivy.ant">
+	<property name="dist.dir" value="${basedir}/dist"/>
+	<property name="build.dir" value="${basedir}/build/react-native-unvired-sdk"/>
+
+	 <scriptdef name="substring" language="javascript">
+	     <attribute name="text" />
+	     <attribute name="start" />
+	     <attribute name="end" />
+	     <attribute name="property" />
+	     <![CDATA[
+	       var text = attributes.get("text");
+	       var start = attributes.get("start");
+	       var end = attributes.get("end") || text.length();
+	       project.setProperty(attributes.get("property"), text.substring(start, end));
+	     ]]>
+  	</scriptdef>
+
+	<scriptdef name="packageversion" language="javascript">
+	    <attribute name="text" />
+	    <attribute name="start" />
+	    <attribute name="end" />
+	    <attribute name="property" />
+	    <![CDATA[
+			var text = attributes.get("text");
+	       	var start = attributes.get("start");
+	       	var end = attributes.get("end") || text.length();
+	       	var newstring = text.substring(start, end);
+			newstring = newstring.replace(/\./g,'~');
+	       	var split = newstring.split("~");
+	       	var first = +split[0];
+	       	first = first.toString();
+	       	var middle = +split[1];
+			middle = middle.toString();
+	       	var last = +split[2];
+			last = last.toString();
+	       	
+	       	newstring = first + '.' + middle + '.' + last;
+	       	project.setProperty(attributes.get("property"), newstring);
+	    ]]>
+  	</scriptdef>  
+
+    <!-- Get the release number -->
+    <target name="getbuildno">
+        <property environment="env" />
+
+        <java jar="/Users/server/Jenkins/BuildNo/BuildNo.jar" fork="true" failonerror="true" maxmemory="128m">
+            <arg value="REACT_NATIVE_UNVIRED_SDK"/>
+            <arg value="-r=true"/>
+            <arg value="-n=true"/>
+        </java>
+
+        <!-- Now read into the build numberfile into release.str property -->
+        <loadfile property="release.str"
+            srcFile="BuildNo.txt" failonerror="true">
+        </loadfile>
+
+        <echo message="Using release number : ${release.str}"/>
+		
+    </target>
+
+	<target name="npminstall" depends="getbuildno">
+		<echo message="Doing npm install"/>
+		<exec executable="npm"  failonerror="true">
+			<arg value="install"/>
+			<arg value="--force"/>
+		</exec>
+    </target>
+
+	<target name="updatebuildno" depends="npminstall">
+		<echo message="Updating build number in service constants file."/>
+		
+		<!-- Release string to be written -->
+		<loadfile property="release.str"
+			srcFile="BuildNo.txt" failonerror="true">
+		</loadfile>
+		<packageversion text="${release.str}" start="2" property="release.num" />
+    </target>
+
+	<target name="updatesource" depends="updatebuildno">
+
+		<!-- Release string to be written -->
+		<loadfile property="release.str"
+			srcFile="BuildNo.txt" failonerror="true">
+		</loadfile>
+
+		<mkdir dir="${dist.dir}"/>
+
+		<property environment="env" />
+
+		<packageversion text="${release.str}" start="2" property="release.num" />
+		<echo message="Using package version number : ${release.num}"/>
+		<replace file="package.json" token="@PACKAGE_NUMBER@" value='${release.num}'/>
+		
+    </target>   
+	
+    <target name="npmpublish" depends="updatesource" if="${env.PUBLISH}">
+		<echo message="Publishing to NPM Registry"/>
+		<exec executable="npm"  failonerror="true">
+			<arg value="publish"/>
+			<arg value="."/>
+		</exec>
+    </target>
+</project>

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger, LogLevel, logger } from './logger/Logger';
+export { default } from './logger/Logger';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Logger, logger } from './logger/Logger';
+export { default } from './logger/Logger';

package/dist/logger/BaseLogger.d.ts

@@ -0,0 +1,18 @@
+export type LogLevel = 'debug' | 'info' | 'error' | 'none';
+export declare const MAX_LOG_SIZE: number;
+export declare class BaseLogger {
+    private impl;
+    private logLevel;
+    constructor();
+    private format;
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
+    log(level: LogLevel, className: string, methodName: string, message: string): Promise<void>;
+    logDebug(c: string, m: string, msg: string): void;
+    logInfo(c: string, m: string, msg: string): void;
+    logError(c: string, m: string, msg: string): void;
+    getLogFileURL(): any;
+    getLogFileContent(): any;
+    getBackupLogFileContent(): any;
+    clearLogFile(): any;
+}

package/dist/logger/BaseLogger.js

@@ -0,0 +1,74 @@
+// BaseLogger.ts
+import { Platform } from 'react-native';
+import { LoggerNative } from './LoggerNative';
+// import { LoggerWindows } from './LoggerWindows';
+import { LoggerWeb } from './LoggerWeb';
+export const MAX_LOG_SIZE = 1 * 1024 * 1024;
+export class BaseLogger {
+    constructor() {
+        this.logLevel = 'info';
+        if (Platform.OS === 'web') {
+            this.impl = new LoggerWeb();
+        }
+        else if (Platform.OS === 'windows') {
+            // this.impl = new LoggerWindows();
+        }
+        else {
+            this.impl = new LoggerNative();
+        }
+        this.impl.init();
+    }
+    // -------------------------
+    // Common formatting logic
+    // -------------------------
+    format(className, methodName, message, level) {
+        const ts = new Date().toISOString();
+        return `--[${ts}] [${level.toUpperCase()}] [${className}] [${methodName}] ${message}`;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    shouldLog(level) {
+        const rank = {
+            debug: 1,
+            info: 2,
+            error: 3,
+            none: 4,
+        };
+        return rank[level] >= rank[this.logLevel];
+    }
+    // -------------------------
+    // Main log function
+    // -------------------------
+    async log(level, className, methodName, message) {
+        if (!this.shouldLog(level))
+            return;
+        const line = this.format(className, methodName, message, level);
+        // console always
+        switch (level) {
+            case 'debug':
+                console.debug(line);
+                break;
+            case 'info':
+                console.info(line);
+                break;
+            case 'error':
+                console.error(line);
+                break;
+        }
+        await this.impl.writeLine(line, MAX_LOG_SIZE);
+    }
+    // -------------------------
+    // Public wrappers
+    // -------------------------
+    logDebug(c, m, msg) { this.log('debug', c, m, msg); }
+    logInfo(c, m, msg) { this.log('info', c, m, msg); }
+    logError(c, m, msg) { this.log('error', c, m, msg); }
+    // -------------------------
+    // File access forwarding
+    // -------------------------
+    getLogFileURL() { return this.impl.getLogFileURL(); }
+    getLogFileContent() { return this.impl.getLogFileContent(); }
+    getBackupLogFileContent() { return this.impl.getBackupLogFileContent(); }
+    clearLogFile() { return this.impl.clear(); }
+}

package/dist/logger/Logger.d.ts

@@ -0,0 +1,6 @@
+import { BaseLogger, LogLevel } from './BaseLogger';
+export declare class Logger extends BaseLogger {
+}
+export declare const logger: Logger;
+export { LogLevel };
+export default logger;

package/dist/logger/Logger.js

@@ -0,0 +1,7 @@
+// Logger.ts
+import { BaseLogger } from './BaseLogger';
+export class Logger extends BaseLogger {
+}
+export const logger = new Logger();
+// Default export (logger instance)
+export default logger;

package/dist/logger/LoggerNative.d.ts

@@ -0,0 +1,15 @@
+export declare class LoggerNative {
+    logDir: string;
+    logFile: string;
+    tempFile: string;
+    backupZip: string;
+    constructor();
+    init(): Promise<void>;
+    writeLine(line: string, maxSize: number): Promise<void>;
+    private ensureDir;
+    rotateLog(): Promise<void>;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string | null>;
+    clear(): Promise<void>;
+}

package/dist/logger/LoggerNative.js

@@ -0,0 +1,84 @@
+// LoggerNative.ts
+import RNFS from 'react-native-fs';
+import { zip } from 'react-native-zip-archive';
+import { Platform } from 'react-native';
+export class LoggerNative {
+    constructor() {
+        const dir = 'unvired_logs';
+        const file = 'applog.txt'; // main log file
+        if (Platform.OS === 'android') {
+            this.logDir = `${RNFS.DocumentDirectoryPath}/${dir}`;
+        }
+        else if (Platform.OS === 'ios') {
+            this.logDir = `${RNFS.LibraryDirectoryPath}/${dir}`;
+        }
+        else {
+            this.logDir = '';
+        }
+        this.logFile = `${this.logDir}/${file}`;
+        this.tempFile = `${this.logDir}/templog.txt`;
+        this.backupZip = `${this.logDir}/backuplog.zip`;
+    }
+    async init() {
+        if (!this.logDir)
+            return;
+        if (!(await RNFS.exists(this.logDir)))
+            await RNFS.mkdir(this.logDir);
+        if (!(await RNFS.exists(this.logFile)))
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+    }
+    async writeLine(line, maxSize) {
+        await this.ensureDir();
+        await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+        const stat = await RNFS.stat(this.logFile);
+        if (Number(stat.size) >= maxSize) {
+            await this.rotateLog();
+        }
+    }
+    async ensureDir() {
+        if (!this.logDir)
+            return;
+        if (!(await RNFS.exists(this.logDir)))
+            await RNFS.mkdir(this.logDir);
+    }
+    async rotateLog() {
+        try {
+            // Step 1: Move current log → temp
+            if (await RNFS.exists(this.tempFile))
+                await RNFS.unlink(this.tempFile);
+            await RNFS.moveFile(this.logFile, this.tempFile);
+            // Step 2: Remove old backup.zip
+            if (await RNFS.exists(this.backupZip))
+                await RNFS.unlink(this.backupZip);
+            // Step 3: Zip temp → backup.zip
+            await zip(this.tempFile, this.backupZip);
+            // Step 4: Clear main log file
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            // Step 5: Remove temp
+            if (await RNFS.exists(this.tempFile))
+                await RNFS.unlink(this.tempFile);
+            console.log('✔ Log rotated to backup.zip successfully');
+        }
+        catch (e) {
+            console.error('❌ Logger rotation error:', e);
+        }
+    }
+    // ------------------------
+    // Public accessors
+    // ------------------------
+    async getLogFileURL() {
+        return this.logFile;
+    }
+    async getLogFileContent() {
+        return (await RNFS.exists(this.logFile)) ? RNFS.readFile(this.logFile, 'utf8') : '';
+    }
+    async getBackupLogFileContent() {
+        return (await RNFS.exists(this.backupZip)) ? RNFS.readFile(this.backupZip, 'base64') : null;
+    }
+    async clear() {
+        if (await RNFS.exists(this.logFile))
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+        if (await RNFS.exists(this.backupZip))
+            await RNFS.unlink(this.backupZip);
+    }
+}

package/dist/logger/LoggerWeb.d.ts

@@ -0,0 +1,8 @@
+export declare class LoggerWeb {
+    init(): Promise<void>;
+    writeLine(line: string): Promise<void>;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string>;
+    clear(): Promise<void>;
+}

package/dist/logger/LoggerWeb.js

@@ -0,0 +1,11 @@
+// LoggerWeb.ts
+export class LoggerWeb {
+    async init() { }
+    async writeLine(line) {
+        console.log(line);
+    }
+    async getLogFileURL() { return ''; }
+    async getLogFileContent() { return ''; }
+    async getBackupLogFileContent() { return ''; }
+    async clear() { }
+}

package/dist/logger/LoggerWindows.d.ts

@@ -0,0 +1,10 @@
+export declare class LoggerWindows {
+    private logFilePath;
+    private backupZipPath;
+    init(): Promise<void>;
+    writeLine(line: string, maxSize: number): Promise<void>;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): any;
+    getBackupLogFileContent(): any;
+    clear(): Promise<void>;
+}

package/dist/logger/LoggerWindows.js

@@ -0,0 +1,44 @@
+// LoggerWindows.ts
+import JSZip from 'jszip';
+const WindowsFS = require('@react-native-windows/fs');
+export class LoggerWindows {
+    constructor() {
+        this.logFilePath = 'C:\\temp\\unvired-sdk.log';
+        this.backupZipPath = 'C:\\temp\\unvired-sdk-backup.zip';
+    }
+    async init() {
+        if (!(await WindowsFS.exists(this.logFilePath))) {
+            await WindowsFS.writeFile(this.logFilePath, '');
+        }
+    }
+    async writeLine(line, maxSize) {
+        const old = await WindowsFS.readFile(this.logFilePath, 'utf8');
+        await WindowsFS.writeFile(this.logFilePath, old + line + '\n');
+        const stat = await WindowsFS.stat(this.logFilePath);
+        if (stat.size < maxSize)
+            return;
+        if (await WindowsFS.exists(this.backupZipPath)) {
+            await WindowsFS.unlink(this.backupZipPath);
+        }
+        const zip = new JSZip();
+        zip.file('unvired-sdk.log', old);
+        const zipped = await zip.generateAsync({ type: 'uint8array' });
+        await WindowsFS.writeFile(this.backupZipPath, zipped);
+        await WindowsFS.writeFile(this.logFilePath, '');
+    }
+    async getLogFileURL() {
+        return this.logFilePath;
+    }
+    getLogFileContent() {
+        return WindowsFS.readFile(this.logFilePath, 'utf8');
+    }
+    getBackupLogFileContent() {
+        return WindowsFS.readFile(this.backupZipPath, 'base64');
+    }
+    async clear() {
+        await WindowsFS.writeFile(this.logFilePath, '');
+        if (await WindowsFS.exists(this.backupZipPath)) {
+            await WindowsFS.unlink(this.backupZipPath);
+        }
+    }
+}

package/example/PlatformInterface.ts

@@ -0,0 +1,11 @@
+export interface PlatformInterface {
+    // Logger
+    logInfo(className: string, methodName: string, message: string): void;
+    logError(className: string, methodName: string, message: string): void;
+    logDebug(className: string, methodName: string, message: string): void;
+    setLogLevel(level: string): void;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string>;
+    clearLogFile(): Promise<void>;
+}

package/example/ReactNativePlatformAdapter.ts

@@ -0,0 +1,40 @@
+import { PlatformInterface } from './PlatformInterface';
+import { logger } from '../src/logger/Logger';
+
+
+export class ReactNativePlatformAdapter implements PlatformInterface {
+
+    // Logger
+    logInfo(className: string, methodName: string, message: string): void {
+        logger.logInfo(className, methodName, message);
+    }
+
+    logError(className: string, methodName: string, message: string): void {
+        logger.logError(className, methodName, message);
+    }
+
+    logDebug(className: string, methodName: string, message: string): void {
+        logger.logDebug(className, methodName, message);
+    }
+
+    setLogLevel(level: string): void {
+        logger.setLogLevel(level);
+    }
+
+    async getLogFileURL(): Promise<string> {
+        return await logger.getLogFileURL();
+    }
+
+    async getLogFileContent(): Promise<string> {
+        return await logger.getLogFileContent();
+    }
+
+    async getBackupLogFileContent(): Promise<string> {
+        return await logger.getBackupLogFileContent();
+    }
+
+    async clearLogFile(): Promise<void> {
+        await logger.clearLogFile();
+    }
+}
+

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@unvired/react-native-unvired-sdk",
+  "version": "0.0.4",
+  "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "prepare": "npm run build",
+    "test": "jest",
+    "lint": "eslint src/",
+    "format": "prettier --write \"src/**/*.{js,ts,tsx}\""
+  },
+  "keywords": [
+    "react-native",
+    "unvired",
+    "sdk",
+    "mobile",
+    "logger",
+    "database",
+    "notifications",
+    "file-system"
+  ],
+  "author": "Unvired",
+  "license": "",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0",
+    "react-native-fs": ">=2.0.0",
+    "react-native-zip-archive": "^7.0.2",
+    "@react-native-windows/fs": "^1.0.2"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-windows/fs": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.72.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "jszip": "^3.10.1"
+  },
+  "repository": {},
+  "bugs": {},
+  "volta": {
+    "node": "25.2.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}