@unvired/react-native-unvired-sdk 0.0.8 → 0.0.10

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0008
+R-0.000.0010

package/README.md

@@ -16,7 +16,7 @@ The **logger works out of the box** with zero dependencies. For additional featu
 
 ```bash
 # For file operations
-npm install react-native-fs
+npm install @dr.pogodin/react-native-fs
 
 # For database (choose one)
 npm install react-native-sqlite-storage  # SQL database
@@ -28,6 +28,23 @@ npm install @notifee/react-native
 
 > **See [NPM_PACKAGES.md](./NPM_PACKAGES.md) for detailed package information and implementation guide.**
 
+### Troubleshooting
+
+If you encounter errors like:
+- `Cannot read property 'RNFSFileTypeRegular' of null`
+- `Cannot read property 'PlatformManager' of undefined`
+- Native module linking issues
+
+**See [TROUBLESHOOTING.md](./TROUBLESHOOTING.md) for detailed solutions.**
+
+The SDK now includes defensive checks and will gracefully handle missing native modules with helpful error messages in the console.
+
+### Migration from react-native-fs
+
+> **Note:** We now use `@dr.pogodin/react-native-fs` (actively maintained fork) instead of the deprecated `react-native-fs`.
+> 
+> If you're upgrading from an older version, see [MIGRATION_GUIDE.md](./MIGRATION_GUIDE.md) for step-by-step instructions.
+
 ## Features
 
 - 📝 **Logger** - Comprehensive logging with multiple log levels ✅ **No dependencies**

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { Logger, LogLevel, logger } from './logger/Logger';
+export { Logger, logger } from './logger/Logger';
+export type { LogLevel, ILogger, ILoggerImplementation, ILoggerConfig, ILogEntry, ILogFileInfo } from './logger/Logger';
 export { default } from './logger/Logger';

package/dist/index.js

@@ -1,2 +1,4 @@
+// Export main logger class and instance
 export { Logger, logger } from './logger/Logger';
+// Default export (logger instance)
 export { default } from './logger/Logger';

package/dist/logger/BaseLogger.d.ts

@@ -1,4 +1,5 @@
-export type LogLevel = 'debug' | 'info' | 'error' | 'none';
+import type { LogLevel } from './Logger.types';
+export type { LogLevel };
 export declare const MAX_LOG_SIZE: number;
 export declare class BaseLogger {
     private impl;
@@ -11,8 +12,17 @@ export declare class BaseLogger {
     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;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string | null>;
+    clearLogFile(): Promise<void>;
+    get logFile(): string;
+    write(message: string): Promise<void>;
+    readLog(): Promise<string>;
+    rotateLog(): Promise<void>;
+    getLogSizes(): Promise<{
+        logFile: number;
+        backupFile: number;
+    }>;
+    private getFileSize;
 }

package/dist/logger/BaseLogger.js

@@ -1,8 +1,7 @@
 // BaseLogger.ts
 import { Platform } from 'react-native';
-import { LoggerNative } from './LoggerNative';
-// import { LoggerWindows } from './LoggerWindows';
-import { LoggerWeb } from './LoggerWeb';
+import { LoggerNative } from './services/LoggerNative';
+import { LoggerWeb } from './services/LoggerWeb';
 export const MAX_LOG_SIZE = 1 * 1024 * 1024;
 export class BaseLogger {
     constructor() {
@@ -11,7 +10,9 @@ export class BaseLogger {
             this.impl = new LoggerWeb();
         }
         else if (Platform.OS === 'windows') {
-            // this.impl = new LoggerWindows();
+            // TODO: Implement LoggerWindows
+            console.warn('Windows logger not implemented yet, using web logger');
+            this.impl = new LoggerWeb();
         }
         else {
             this.impl = new LoggerNative();
@@ -71,4 +72,47 @@ export class BaseLogger {
     getLogFileContent() { return this.impl.getLogFileContent(); }
     getBackupLogFileContent() { return this.impl.getBackupLogFileContent(); }
     clearLogFile() { return this.impl.clear(); }
+    // -------------------------
+    // ILogger interface compatibility
+    // -------------------------
+    get logFile() {
+        return this.impl.logFile || '';
+    }
+    async write(message) {
+        const line = `[${new Date().toISOString()}] ${message}`;
+        await this.impl.writeLine(line, MAX_LOG_SIZE);
+    }
+    async readLog() {
+        return this.impl.getLogFileContent();
+    }
+    async rotateLog() {
+        if (this.impl.rotateLog) {
+            await this.impl.rotateLog();
+        }
+        else {
+            // For Windows, force rotation by writing max size
+            await this.impl.writeLine('', Number.MAX_SAFE_INTEGER);
+        }
+    }
+    async getLogSizes() {
+        const logSize = await this.getFileSize(this.impl.logFile);
+        const backupSize = await this.getFileSize(this.impl.backupZip || this.impl.tempFile || '');
+        return { logFile: logSize, backupFile: backupSize };
+    }
+    async getFileSize(path) {
+        if (!path)
+            return 0;
+        try {
+            // Try to use RNFS if available
+            const RNFS = require('@dr.pogodin/react-native-fs');
+            if (await RNFS.exists(path)) {
+                const stat = await RNFS.stat(path);
+                return stat.size;
+            }
+        }
+        catch {
+            // Ignore
+        }
+        return 0;
+    }
 }

package/dist/logger/Logger.d.ts

@@ -2,5 +2,6 @@ import { BaseLogger, LogLevel } from './BaseLogger';
 export declare class Logger extends BaseLogger {
 }
 export declare const logger: Logger;
-export { LogLevel };
+export type { ILogger, ILoggerImplementation, ILoggerConfig, ILogEntry, ILogFileInfo, } from './Logger.types';
+export type { LogLevel };
 export default logger;

package/dist/logger/Logger.js

@@ -1,7 +1,12 @@
 // Logger.ts
 import { BaseLogger } from './BaseLogger';
+// Export the Logger class
 export class Logger extends BaseLogger {
 }
+// Export the singleton logger instance
 export const logger = new Logger();
 // Default export (logger instance)
 export default logger;
+// adb shell
+// run-as com.rnturboapp
+// ls -lh files/localLogs

package/dist/logger/Logger.types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Log levels supported by the logger
+ */
+export type LogLevel = 'debug' | 'info' | 'error' | 'none';
+/**
+ * Interface for platform-specific logger implementations
+ * This interface must be implemented by LoggerNative, LoggerWindows, and LoggerWeb
+ */
+export interface ILoggerImplementation {
+    logDir?: string;
+    logFile: string;
+    tempFile?: string;
+    backupZip?: string;
+    init(): Promise<void>;
+    writeLine(line: string, maxSize: number): Promise<void>;
+    rotateLog?(): Promise<void>;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string | null>;
+    clear(): Promise<void>;
+}
+/**
+ * Public API interface for the logger
+ * This is what consumers of the logger package should use
+ */
+export interface ILogger {
+    logFile: string;
+    setLogLevel?(level: LogLevel): void;
+    logDebug?(className: string, methodName: string, message: string): void;
+    logInfo?(className: string, methodName: string, message: string): void;
+    logError?(className: string, methodName: string, message: string): void;
+    write(message: string): Promise<void>;
+    readLog(): Promise<string>;
+    rotateLog(): Promise<void>;
+    getLogSizes(): Promise<{
+        logFile: number;
+        backupFile: number;
+    }>;
+    getLogFileURL?(): Promise<string>;
+    getLogFileContent?(): Promise<string>;
+    getBackupLogFileContent(): Promise<string | null>;
+    clearLogFile?(): Promise<void>;
+}
+/**
+ * Configuration options for logger initialization
+ */
+export interface ILoggerConfig {
+    logLevel?: LogLevel;
+    maxLogSize?: number;
+    logDir?: string;
+    logFileName?: string;
+}
+/**
+ * Log entry structure
+ */
+export interface ILogEntry {
+    timestamp: string;
+    level: LogLevel;
+    className?: string;
+    methodName?: string;
+    message: string;
+}
+/**
+ * Log file information
+ */
+export interface ILogFileInfo {
+    path: string;
+    size: number;
+    exists: boolean;
+    lastModified?: Date;
+}

package/dist/logger/Logger.types.js

@@ -0,0 +1,3 @@
+// Logger.types.ts
+// Type definitions for the logger package
+export {};

package/dist/logger/{LoggerNative.d.ts → services/LoggerNative.d.ts}

@@ -1,15 +1,17 @@
-export declare class LoggerNative {
+import type { ILoggerImplementation } from '../Logger.types';
+export declare class LoggerNative implements ILoggerImplementation {
     logDir: string;
     logFile: string;
-    tempFile: string;
     backupZip: string;
+    private isRotating;
+    private isAvailable;
     constructor();
     init(): Promise<void>;
     writeLine(line: string, maxSize: number): Promise<void>;
     private ensureDir;
     rotateLog(): Promise<void>;
     getLogFileURL(): Promise<string>;
-    getLogFileContent(): Promise<string>;
+    getLogFileContent(): Promise<any>;
     getBackupLogFileContent(): Promise<string | null>;
     clear(): Promise<void>;
 }

package/dist/logger/services/LoggerNative.js

@@ -0,0 +1,212 @@
+// LoggerNative.ts
+import { Platform } from 'react-native';
+// Import with null safety
+let RNFS = null;
+let zip = null;
+try {
+    RNFS = require('@dr.pogodin/react-native-fs');
+    if (!RNFS || !RNFS.DocumentDirectoryPath) {
+        console.error('❌ @dr.pogodin/react-native-fs is not properly linked. Please run: cd ios && pod install (iOS) or rebuild your Android app.');
+        RNFS = null;
+    }
+}
+catch (e) {
+    console.error('❌ @dr.pogodin/react-native-fs module not found. Please install: npm install @dr.pogodin/react-native-fs');
+}
+try {
+    const zipModule = require('react-native-zip-archive');
+    zip = zipModule.zip;
+    if (!zip) {
+        console.error('❌ react-native-zip-archive is not properly linked. Please run: cd ios && pod install (iOS) or rebuild your Android app.');
+    }
+}
+catch (e) {
+    console.error('❌ react-native-zip-archive module not found. Please install: npm install react-native-zip-archive');
+}
+export class LoggerNative {
+    constructor() {
+        this.isRotating = false; // Rotation lock to prevent concurrent rotations
+        this.isAvailable = false;
+        const dir = 'unvired_logs_local';
+        const file = 'applog.txt'; // main log file
+        if (!RNFS) {
+            console.warn('⚠️ LoggerNative: RNFS not available, logging to file system disabled');
+            this.logDir = '';
+            this.logFile = '';
+            this.backupZip = '';
+            return;
+        }
+        this.isAvailable = true;
+        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.backupZip = `${this.logDir}/backuplog.zip`;
+    }
+    async init() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+            if (!(await RNFS.exists(this.logFile)))
+                await RNFS.writeFile(this.logFile, '', 'utf8');
+        }
+        catch (e) {
+            console.error('❌ LoggerNative init error:', e);
+        }
+    }
+    async writeLine(line, maxSize) {
+        if (!this.isAvailable || !RNFS)
+            return;
+        try {
+            await this.ensureDir();
+            await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+            // Only check for rotation if not already rotating
+            if (!this.isRotating) {
+                const stat = await RNFS.stat(this.logFile);
+                if (Number(stat.size) >= maxSize) {
+                    // Don't await - let rotation happen in background
+                    this.rotateLog();
+                }
+            }
+        }
+        catch (e) {
+            console.error('❌ LoggerNative writeLine error:', e);
+        }
+    }
+    async ensureDir() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+        }
+        catch (e) {
+            console.error('❌ LoggerNative ensureDir error:', e);
+        }
+    }
+    async rotateLog() {
+        if (!this.isAvailable || !RNFS || !zip) {
+            console.warn('⚠️ LoggerNative: Cannot rotate log, RNFS or zip not available');
+            return;
+        }
+        // Prevent concurrent rotations
+        if (this.isRotating) {
+            console.log('⏭️ Rotation already in progress, skipping...');
+            return;
+        }
+        this.isRotating = true;
+        try {
+            console.log('🔄 Starting log rotation...');
+            // Check if log file exists and get its size
+            if (!(await RNFS.exists(this.logFile))) {
+                console.log('⚠️ Log file does not exist, skipping rotation');
+                return;
+            }
+            const stat = await RNFS.stat(this.logFile);
+            console.log(`📊 Current log file size: ${stat.size} bytes`);
+            // Step 1: Remove old backup.zip if it exists
+            if (await RNFS.exists(this.backupZip)) {
+                console.log('🗑️ Removing old backup.zip');
+                await RNFS.unlink(this.backupZip);
+            }
+            // Step 2: Create a temporary directory for zipping
+            // react-native-zip-archive requires a directory, not a single file
+            const tempZipDir = `${this.logDir}/temp_zip`;
+            if (await RNFS.exists(tempZipDir)) {
+                await RNFS.unlink(tempZipDir);
+            }
+            await RNFS.mkdir(tempZipDir);
+            // Step 3: Copy current log file into the temp directory
+            const tempFileInDir = `${tempZipDir}/applog.txt`;
+            console.log('📦 Copying log file to temp directory for zipping');
+            await RNFS.copyFile(this.logFile, tempFileInDir);
+            // Step 4: Zip the directory → backup.zip
+            console.log('🗜️ Creating backup.zip from current log');
+            await zip(tempZipDir, this.backupZip);
+            const zipStat = await RNFS.stat(this.backupZip);
+            console.log(`✅ Backup.zip created successfully (${zipStat.size} bytes)`);
+            // Step 5: Clean up temp directory
+            console.log('🧹 Cleaning up temp directory');
+            if (await RNFS.exists(tempZipDir)) {
+                await RNFS.unlink(tempZipDir);
+            }
+            // Step 6: Clear the current log file (make it fresh/empty)
+            console.log('📝 Clearing current log file');
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            console.log('✔ Log rotation completed successfully');
+            console.log('📂 Files: applog.txt (fresh) + backuplog.zip (old logs)');
+        }
+        catch (e) {
+            console.error('❌ Logger rotation error:', e);
+            // Try to recover by creating a fresh log file if it doesn't exist
+            try {
+                if (!(await RNFS.exists(this.logFile))) {
+                    await RNFS.writeFile(this.logFile, '', 'utf8');
+                    console.log('🔧 Recovery: Created fresh log file');
+                }
+            }
+            catch (recoveryError) {
+                console.error('❌ Recovery failed:', recoveryError);
+            }
+        }
+        finally {
+            // Always release the lock
+            this.isRotating = false;
+        }
+    }
+    // ------------------------
+    // Public accessors
+    // ------------------------
+    async getLogFileURL() {
+        if (!this.isAvailable)
+            return '';
+        return this.logFile;
+    }
+    async getLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return '';
+        try {
+            return (await RNFS.exists(this.logFile)) ? RNFS.readFile(this.logFile, 'utf8') : '';
+        }
+        catch (e) {
+            console.error('❌ LoggerNative getLogFileContent error:', e);
+            return '';
+        }
+    }
+    async getBackupLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return null;
+        try {
+            if (await RNFS.exists(this.backupZip)) {
+                const stat = await RNFS.stat(this.backupZip);
+                return `${stat.size}`;
+            }
+            return null;
+        }
+        catch (e) {
+            console.error('❌ LoggerNative getBackupLogFileContent error:', e);
+            return null;
+        }
+    }
+    async clear() {
+        if (!this.isAvailable || !RNFS)
+            return;
+        try {
+            if (await RNFS.exists(this.logFile))
+                await RNFS.writeFile(this.logFile, '', 'utf8');
+            if (await RNFS.exists(this.backupZip))
+                await RNFS.unlink(this.backupZip);
+        }
+        catch (e) {
+            console.error('❌ LoggerNative clear error:', e);
+        }
+    }
+}

package/dist/logger/services/LoggerWeb.d.ts

@@ -0,0 +1,10 @@
+import type { ILoggerImplementation } from '../Logger.types';
+export declare class LoggerWeb implements ILoggerImplementation {
+    logFile: string;
+    init(): Promise<void>;
+    writeLine(line: string, maxSize: number): Promise<void>;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<null>;
+    clear(): Promise<void>;
+}

package/dist/logger/{LoggerWeb.js → services/LoggerWeb.js}

@@ -1,11 +1,13 @@
-// LoggerWeb.ts
 export class LoggerWeb {
+    constructor() {
+        this.logFile = '';
+    }
     async init() { }
-    async writeLine(line) {
+    async writeLine(line, maxSize) {
         console.log(line);
     }
     async getLogFileURL() { return ''; }
     async getLogFileContent() { return ''; }
-    async getBackupLogFileContent() { return ''; }
+    async getBackupLogFileContent() { return null; }
     async clear() { }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,17 +24,12 @@
   "author": "Unvired",
   "license": "UNLICENSED",
   "peerDependencies": {
+    "@dr.pogodin/react-native-fs": "^2.36.2",
     "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
-    }
+    "react-native-zip-archive": "^7.0.2"
   },
+  "peerDependenciesMeta": {},
   "devDependencies": {
     "@types/react": "^18.0.0",
     "@types/react-native": "^0.72.0",
@@ -43,9 +38,7 @@
     "prettier": "^3.0.0",
     "typescript": "^5.0.0"
   },
-  "dependencies": {
-    "jszip": "^3.10.1"
-  },
+  "dependencies": {},
   "repository": {},
   "bugs": {},
   "volta": {
@@ -54,4 +47,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/dist/logger/LoggerNative.js

@@ -1,84 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-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/LoggerWindows.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,44 +0,0 @@
-// 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

@@ -1,11 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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();
-    }
-}
-