@unvired/react-native-unvired-sdk 0.0.11 → 0.0.13

package/dist/file-system/BaseFileSystem.d.ts

@@ -0,0 +1,60 @@
+import * as RNFS from '@dr.pogodin/react-native-fs';
+import { IFileEntry } from './FileSystem.types';
+/**
+ * Base File System Class
+ * Handles file system operations for React Native
+ */
+export declare class BaseFileSystem {
+    /**
+     * Get document directory path
+     */
+    static getDocumentDirectory(): string;
+    /**
+     * Resolve local file system URL
+     */
+    static resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    /**
+     * Get folder based on user ID
+     */
+    static getFolderBasedOnUserId(userId: string): Promise<string>;
+    /**
+     * Delete user folder
+     */
+    static deleteUserFolder(userId: string): Promise<void>;
+    /**
+     * Create directory
+     */
+    static createDirectory(path: string): Promise<void>;
+    /**
+     * Read file content
+     */
+    static readFile(path: string, encoding?: RNFS.EncodingT): Promise<string>;
+    /**
+     * Write file content
+     */
+    static writeFile(path: string, content: string, encoding?: RNFS.EncodingT): Promise<void>;
+    /**
+     * Delete file
+     */
+    static deleteFile(path: string): Promise<void>;
+    /**
+     * Check if file exists
+     */
+    static exists(path: string): Promise<boolean>;
+    /**
+     * Get file info
+     */
+    static stat(path: string): Promise<RNFS.StatResultT>;
+    /**
+     * List directory contents
+     */
+    static readDir(path: string): Promise<RNFS.ReadDirResItemT[]>;
+    /**
+     * Copy file
+     */
+    static copyFile(source: string, destination: string): Promise<void>;
+    /**
+     * Move file
+     */
+    static moveFile(source: string, destination: string): Promise<void>;
+}

package/dist/file-system/BaseFileSystem.js

@@ -0,0 +1,194 @@
+// BaseFileSystem.ts
+// Base file system implementation
+import * as RNFS from '@dr.pogodin/react-native-fs';
+/**
+ * Base File System Class
+ * Handles file system operations for React Native
+ */
+export class BaseFileSystem {
+    /**
+     * Get document directory path
+     */
+    static getDocumentDirectory() {
+        return RNFS.DocumentDirectoryPath;
+    }
+    /**
+     * Resolve local file system URL
+     */
+    static async resolveLocalFileSystemURL(url) {
+        try {
+            let normalizedPath = url;
+            if (normalizedPath.startsWith('file://')) {
+                normalizedPath = normalizedPath.substring(7);
+            }
+            const exists = await RNFS.exists(normalizedPath);
+            if (!exists) {
+                throw new Error(`File or directory does not exist: ${normalizedPath}`);
+            }
+            const stat = await RNFS.stat(normalizedPath);
+            // Extract filename from path if stat.name is undefined
+            const fileName = stat.name || normalizedPath.split('/').pop() || 'unknown';
+            const fileEntry = {
+                isFile: stat.isFile(),
+                isDirectory: stat.isDirectory(),
+                name: fileName,
+                fullPath: stat.path,
+                nativeURL: `file://${stat.path}`,
+            };
+            return fileEntry;
+        }
+        catch (error) {
+            console.error('Error resolving file system URL:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get folder based on user ID
+     */
+    static async getFolderBasedOnUserId(userId) {
+        try {
+            const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
+            const exists = await RNFS.exists(userFolder);
+            if (!exists) {
+                await RNFS.mkdir(userFolder, {
+                    NSURLIsExcludedFromBackupKey: true,
+                });
+            }
+            return userFolder;
+        }
+        catch (error) {
+            console.error('Error getting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete user folder
+     */
+    static async deleteUserFolder(userId) {
+        try {
+            const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
+            const exists = await RNFS.exists(userFolder);
+            if (exists) {
+                await RNFS.unlink(userFolder);
+                console.log(`User folder deleted: ${userFolder}`);
+            }
+        }
+        catch (error) {
+            console.error('Error deleting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create directory
+     */
+    static async createDirectory(path) {
+        try {
+            const exists = await RNFS.exists(path);
+            if (!exists) {
+                await RNFS.mkdir(path);
+            }
+        }
+        catch (error) {
+            console.error('Error creating directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Read file content
+     */
+    static async readFile(path, encoding = 'utf8') {
+        try {
+            return await RNFS.readFile(path, encoding);
+        }
+        catch (error) {
+            console.error('Error reading file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Write file content
+     */
+    static async writeFile(path, content, encoding = 'utf8') {
+        try {
+            await RNFS.writeFile(path, content, encoding);
+        }
+        catch (error) {
+            console.error('Error writing file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete file
+     */
+    static async deleteFile(path) {
+        try {
+            const exists = await RNFS.exists(path);
+            if (exists) {
+                await RNFS.unlink(path);
+            }
+        }
+        catch (error) {
+            console.error('Error deleting file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if file exists
+     */
+    static async exists(path) {
+        try {
+            return await RNFS.exists(path);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get file info
+     */
+    static async stat(path) {
+        try {
+            return await RNFS.stat(path);
+        }
+        catch (error) {
+            console.error('Error getting file stats:', error);
+            throw error;
+        }
+    }
+    /**
+     * List directory contents
+     */
+    static async readDir(path) {
+        try {
+            return await RNFS.readDir(path);
+        }
+        catch (error) {
+            console.error('Error reading directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Copy file
+     */
+    static async copyFile(source, destination) {
+        try {
+            await RNFS.copyFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error copying file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Move file
+     */
+    static async moveFile(source, destination) {
+        try {
+            await RNFS.moveFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error moving file:', error);
+            throw error;
+        }
+    }
+}

package/dist/file-system/FileSystem.d.ts

@@ -0,0 +1,9 @@
+import { BaseFileSystem } from './BaseFileSystem';
+/**
+ * FileSystem class
+ * Extends BaseFileSystem
+ */
+export declare class FileSystem extends BaseFileSystem {
+}
+export type { IFileEntry } from './FileSystem.types';
+export default FileSystem;

package/dist/file-system/FileSystem.js

@@ -0,0 +1,11 @@
+// FileSystem.ts
+// Main file system export
+import { BaseFileSystem } from './BaseFileSystem';
+/**
+ * FileSystem class
+ * Extends BaseFileSystem
+ */
+export class FileSystem extends BaseFileSystem {
+}
+// Default export
+export default FileSystem;

package/dist/file-system/FileSystem.types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * File entry interface
+ */
+export interface IFileEntry {
+    isFile: boolean;
+    isDirectory: boolean;
+    name: string;
+    fullPath: string;
+    filesystem?: any;
+    nativeURL?: string;
+}

package/dist/file-system/FileSystem.types.js

@@ -0,0 +1,3 @@
+// FileSystem.types.ts
+// Type definitions for file system module
+export {};

package/dist/file-system/index.d.ts

@@ -0,0 +1,3 @@
+export { FileSystem } from './FileSystem';
+export type { IFileEntry } from './FileSystem.types';
+export { default } from './FileSystem';

package/dist/file-system/index.js

@@ -0,0 +1,3 @@
+// File System module exports
+export { FileSystem } from './FileSystem';
+export { default } from './FileSystem';

package/dist/local-storage/index.d.ts

@@ -0,0 +1 @@
+export { LocalStorage } from './localStorage';

package/dist/local-storage/index.js

@@ -0,0 +1,2 @@
+// Local Storage module exports
+export { LocalStorage } from './localStorage';

package/dist/local-storage/localStorage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * LocalStorage class provides a wrapper around React Native AsyncStorage
+ * with convenient methods for storing and retrieving data.
+ */
+export declare class LocalStorage {
+    /**
+     * Get an item from storage
+     * @param key - The key to retrieve
+     * @returns The parsed value or null if not found
+     */
+    static getItem<T = any>(key: string): Promise<T | null>;
+    /**
+     * Set an item in storage
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON stringified)
+     */
+    static setItem(key: string, value: any): Promise<void>;
+    /**
+     * Remove an item from storage
+     * @param key - The key to remove
+     */
+    static removeItem(key: string): Promise<void>;
+    /**
+     * Clear all items from storage
+     */
+    static clear(): Promise<void>;
+    /**
+     * Get all keys from storage
+     * @returns Array of all keys
+     */
+    static getAllKeys(): Promise<readonly string[]>;
+    /**
+     * Get multiple items from storage
+     * @param keys - Array of keys to retrieve
+     * @returns Array of [key, value] pairs
+     */
+    static multiGet(keys: string[]): Promise<Array<[string, any]>>;
+    /**
+     * Set multiple items in storage
+     * @param keyValuePairs - Array of [key, value] pairs to store
+     */
+    static multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    /**
+     * Remove multiple items from storage
+     * @param keys - Array of keys to remove
+     */
+    static multiRemove(keys: string[]): Promise<void>;
+}

package/dist/local-storage/localStorage.js

@@ -0,0 +1,123 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+/**
+ * LocalStorage class provides a wrapper around React Native AsyncStorage
+ * with convenient methods for storing and retrieving data.
+ */
+export class LocalStorage {
+    /**
+     * Get an item from storage
+     * @param key - The key to retrieve
+     * @returns The parsed value or null if not found
+     */
+    static async getItem(key) {
+        try {
+            const value = await AsyncStorage.getItem(key);
+            return value ? JSON.parse(value) : null;
+        }
+        catch (error) {
+            console.error(`Error getting item with key "${key}":`, error);
+            return null;
+        }
+    }
+    /**
+     * Set an item in storage
+     * @param key - The key to store the value under
+     * @param value - The value to store (will be JSON stringified)
+     */
+    static async setItem(key, value) {
+        try {
+            const jsonValue = JSON.stringify(value);
+            await AsyncStorage.setItem(key, jsonValue);
+        }
+        catch (error) {
+            console.error(`Error setting item with key "${key}":`, error);
+            throw error;
+        }
+    }
+    /**
+     * Remove an item from storage
+     * @param key - The key to remove
+     */
+    static async removeItem(key) {
+        try {
+            await AsyncStorage.removeItem(key);
+        }
+        catch (error) {
+            console.error(`Error removing item with key "${key}":`, error);
+            throw error;
+        }
+    }
+    /**
+     * Clear all items from storage
+     */
+    static async clear() {
+        try {
+            await AsyncStorage.clear();
+        }
+        catch (error) {
+            console.error('Error clearing storage:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get all keys from storage
+     * @returns Array of all keys
+     */
+    static async getAllKeys() {
+        try {
+            return await AsyncStorage.getAllKeys();
+        }
+        catch (error) {
+            console.error('Error getting all keys:', error);
+            return [];
+        }
+    }
+    /**
+     * Get multiple items from storage
+     * @param keys - Array of keys to retrieve
+     * @returns Array of [key, value] pairs
+     */
+    static async multiGet(keys) {
+        try {
+            const results = await AsyncStorage.multiGet(keys);
+            return results.map(([key, value]) => [
+                key,
+                value ? JSON.parse(value) : null
+            ]);
+        }
+        catch (error) {
+            console.error('Error getting multiple items:', error);
+            return [];
+        }
+    }
+    /**
+     * Set multiple items in storage
+     * @param keyValuePairs - Array of [key, value] pairs to store
+     */
+    static async multiSet(keyValuePairs) {
+        try {
+            const jsonPairs = keyValuePairs.map(([key, value]) => [
+                key,
+                JSON.stringify(value)
+            ]);
+            await AsyncStorage.multiSet(jsonPairs);
+        }
+        catch (error) {
+            console.error('Error setting multiple items:', error);
+            throw error;
+        }
+    }
+    /**
+     * Remove multiple items from storage
+     * @param keys - Array of keys to remove
+     */
+    static async multiRemove(keys) {
+        try {
+            await AsyncStorage.multiRemove(keys);
+        }
+        catch (error) {
+            console.error('Error removing multiple items:', error);
+            throw error;
+        }
+    }
+}

package/dist/logger/BaseLogger.js

@@ -2,6 +2,7 @@
 import { Platform } from 'react-native';
 import { LoggerNative } from './services/LoggerNative';
 import { LoggerWeb } from './services/LoggerWeb';
+import { LoggerWindows } from './services/LoggerWindows';
 export const MAX_LOG_SIZE = 100 * 1024 * 1024;
 export class BaseLogger {
     constructor() {
@@ -10,9 +11,7 @@ export class BaseLogger {
             this.impl = new LoggerWeb();
         }
         else if (Platform.OS === 'windows') {
-            // TODO: Implement LoggerWindows
-            console.warn('Windows logger not implemented yet, using web logger');
-            this.impl = new LoggerWeb();
+            this.impl = new LoggerWindows();
         }
         else {
             this.impl = new LoggerNative();
@@ -24,7 +23,7 @@ export class BaseLogger {
     // -------------------------
     format(className, methodName, message, level) {
         const ts = new Date().toISOString();
-        return `--[${ts}] [${level.toUpperCase()}] [${className}] [${methodName}] ${message}`;
+        return `[${ts}] [${level.toUpperCase()}] [${className}] [${methodName}] ${message}`;
     }
     setLogLevel(level) {
         this.logLevel = level;
@@ -46,17 +45,13 @@ export class BaseLogger {
             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;
+            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);
     }
     // -------------------------

package/dist/logger/{Logger.js → index.js}

@@ -1,4 +1,4 @@
-// Logger.ts
+// Logger module main file
 import { BaseLogger } from './BaseLogger';
 // Export the Logger class
 export class Logger extends BaseLogger {
@@ -7,6 +7,3 @@ export class Logger extends BaseLogger {
 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/services/LoggerNative.js

@@ -27,8 +27,8 @@ export class LoggerNative {
     constructor() {
         this.isRotating = false; // Rotation lock to prevent concurrent rotations
         this.isAvailable = false;
-        const dir = 'unvired_logs_local';
-        const file = 'applog_local.txt'; // main log file
+        const dir = 'unvired_logs';
+        const file = 'applog.txt'; // main log file
         if (!RNFS) {
             console.warn('⚠️ LoggerNative: RNFS not available, logging to file system disabled');
             this.logDir = '';
@@ -47,7 +47,7 @@ export class LoggerNative {
             this.logDir = '';
         }
         this.logFile = `${this.logDir}/${file}`;
-        this.backupZip = `${this.logDir}/backuplog_local.zip`;
+        this.backupZip = `${this.logDir}/backuplog.zip`;
     }
     async init() {
         if (!this.isAvailable || !this.logDir || !RNFS)
@@ -188,8 +188,8 @@ export class LoggerNative {
         if (!this.isAvailable || !RNFS)
             return null;
         try {
-            // Force rotation to ensure current logs are zipped
-            await this.rotateLog();
+            // Do NOT force rotation. Only return existing backup if present.
+            // await this.rotateLog();
             if (await RNFS.exists(this.backupZip)) {
                 // Return base64 content for download/upload
                 return await RNFS.readFile(this.backupZip, 'base64');

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

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