@unvired/react-native-unvired-sdk 0.0.33 → 0.0.35

package/dist/file-system/services/FileSystemWeb.js

@@ -1,41 +1,274 @@
+class WebDirectoryReader {
+    constructor(fullPath) {
+        this.fullPath = fullPath;
+    }
+    readEntries(successCallback, errorCallback) {
+        try {
+            const entries = [];
+            const prefix = `__vfs_${this.fullPath}/`;
+            if (typeof localStorage !== "undefined") {
+                for (let i = 0; i < localStorage.length; i++) {
+                    const key = localStorage.key(i);
+                    if (key && key.startsWith(prefix)) {
+                        const relPath = key.substring(prefix.length);
+                        const segment = relPath.split("/")[0];
+                        const entryFullPath = `${this.fullPath}/${segment}`;
+                        const isDir = relPath.includes("/");
+                        if (!entries.find((e) => e.fullPath === entryFullPath)) {
+                            entries.push(new WebFileEntry(entryFullPath, isDir));
+                        }
+                    }
+                }
+            }
+            successCallback(entries);
+        }
+        catch (e) {
+            errorCallback(e);
+        }
+    }
+}
+class WebFileEntry {
+    constructor(fullPath, isDirectory) {
+        this.fullPath = fullPath.replace(/\/+/g, "/");
+        this.name = this.fullPath.split("/").filter(Boolean).pop() || "root";
+        this.isFile = !isDirectory;
+        this.isDirectory = isDirectory;
+        this.nativeURL = `file://${this.fullPath}`;
+    }
+    remove(callback, errorCallback) {
+        try {
+            if (typeof localStorage !== "undefined") {
+                localStorage.removeItem(`__vfs_${this.fullPath}`);
+            }
+            callback();
+        }
+        catch (e) {
+            errorCallback(e);
+        }
+    }
+    removeRecursively(callback, errorCallback) {
+        try {
+            if (typeof localStorage !== "undefined") {
+                const prefix = `__vfs_${this.fullPath}`;
+                const keysToRemove = [];
+                for (let i = 0; i < localStorage.length; i++) {
+                    const key = localStorage.key(i);
+                    if (key && (key === prefix || key.startsWith(`${prefix}/`))) {
+                        keysToRemove.push(key);
+                    }
+                }
+                keysToRemove.forEach((k) => localStorage.removeItem(k));
+            }
+            callback();
+        }
+        catch (e) {
+            errorCallback(e);
+        }
+    }
+    createReader() {
+        return new WebDirectoryReader(this.fullPath);
+    }
+    getDirectory(path, options, callback, errorCallback) {
+        const dirPath = `${this.fullPath}/${path}`.replace(/\/+/g, "/");
+        const entry = new WebFileEntry(dirPath, true);
+        if ((options === null || options === void 0 ? void 0 : options.create) && typeof localStorage !== "undefined") {
+            localStorage.setItem(`__vfs_${dirPath}`, JSON.stringify({ isDir: true }));
+        }
+        callback(entry);
+    }
+    getFile(path, options, callback, errorCallback) {
+        const filePath = `${this.fullPath}/${path}`.replace(/\/+/g, "/");
+        const key = `__vfs_${filePath}`;
+        if ((options === null || options === void 0 ? void 0 : options.create) && typeof localStorage !== "undefined") {
+            if (localStorage.getItem(key) === null) {
+                localStorage.setItem(key, "");
+            }
+        }
+        const entry = new WebFileEntry(filePath, false);
+        callback(entry);
+    }
+    file(callback, errorCallback) {
+        try {
+            let content = "";
+            if (typeof localStorage !== "undefined") {
+                content = localStorage.getItem(`__vfs_${this.fullPath}`) || "";
+            }
+            const fileObj = {
+                name: this.name,
+                size: content.length,
+                type: "text/plain",
+                lastModified: Date.now(),
+                lastModifiedDate: new Date(),
+                path: this.fullPath,
+            };
+            callback(fileObj);
+        }
+        catch (e) {
+            errorCallback(e);
+        }
+    }
+    createWriter(callback, errorCallback) {
+        const filePath = this.fullPath;
+        const writer = {
+            filePath,
+            write: (data) => {
+                try {
+                    if (typeof localStorage !== "undefined") {
+                        localStorage.setItem(`__vfs_${filePath}`, data);
+                    }
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                    return Promise.resolve();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                    return Promise.reject(err);
+                }
+            },
+            append: (data) => {
+                try {
+                    if (typeof localStorage !== "undefined") {
+                        const existing = localStorage.getItem(`__vfs_${filePath}`) || "";
+                        localStorage.setItem(`__vfs_${filePath}`, existing + data);
+                    }
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                    return Promise.resolve();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                    return Promise.reject(err);
+                }
+            },
+            truncate: (size) => {
+                try {
+                    if (typeof localStorage !== "undefined") {
+                        const existing = localStorage.getItem(`__vfs_${filePath}`) || "";
+                        localStorage.setItem(`__vfs_${filePath}`, existing.substring(0, size));
+                    }
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                    return Promise.resolve();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                    return Promise.reject(err);
+                }
+            },
+            seek: () => Promise.resolve(),
+            onwriteend: null,
+            onerror: null,
+        };
+        callback(writer);
+    }
+}
+/**
+ * FileSystemWeb - Virtual browser-backed file system with localStorage persistence
+ */
 export class FileSystemWeb {
+    constructor() {
+        this.baseDir = "/virtual-fs";
+    }
     getDocumentDirectory() {
-        return '/virtual-fs';
+        return this.baseDir;
     }
     async resolveLocalFileSystemURL(url) {
-        throw new Error('File system operations not supported on web');
+        const path = url.replace(/^file:\/\//, "");
+        return new WebFileEntry(path, false);
     }
     async getFolderBasedOnUserId(userId) {
-        return `/virtual-fs/users/${userId}`;
+        const folder = `${this.baseDir}/users/${userId}`;
+        await this.createDirectory(folder);
+        return `file://${folder}`;
     }
     async deleteUserFolder(userId) {
-        console.warn('deleteUserFolder not supported on web');
+        const prefix = `__vfs_${this.baseDir}/users/${userId}`;
+        if (typeof localStorage !== "undefined") {
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && (key === prefix || key.startsWith(`${prefix}/`))) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach((k) => localStorage.removeItem(k));
+        }
     }
     async createDirectory(path) {
-        console.warn('createDirectory not supported on web');
+        if (typeof localStorage !== "undefined") {
+            localStorage.setItem(`__vfs_${path}`, JSON.stringify({ isDir: true }));
+        }
     }
-    async readFile(path, encoding) {
-        throw new Error('readFile not supported on web');
+    async readFile(path, encoding = "utf8") {
+        if (typeof localStorage !== "undefined") {
+            const val = localStorage.getItem(`__vfs_${path}`);
+            if (val !== null)
+                return val;
+        }
+        throw new Error(`File not found: ${path}`);
     }
-    async writeFile(path, content, encoding) {
-        throw new Error('writeFile not supported on web');
+    async writeFile(path, content, encoding = "utf8") {
+        if (typeof localStorage !== "undefined") {
+            localStorage.setItem(`__vfs_${path}`, content);
+        }
     }
     async deleteFile(path) {
-        console.warn('deleteFile not supported on web');
+        if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(`__vfs_${path}`);
+        }
     }
     async exists(path) {
+        if (typeof localStorage !== "undefined") {
+            return localStorage.getItem(`__vfs_${path}`) !== null;
+        }
         return false;
     }
     async stat(path) {
-        throw new Error('stat not supported on web');
+        let size = 0;
+        if (typeof localStorage !== "undefined") {
+            const val = localStorage.getItem(`__vfs_${path}`);
+            if (val !== null)
+                size = val.length;
+        }
+        return {
+            size,
+            isFile: () => true,
+            isDirectory: () => false,
+            mtime: new Date(),
+            ctime: new Date(),
+        };
     }
     async readDir(path) {
-        return [];
+        const prefix = `__vfs_${path}/`;
+        const results = [];
+        if (typeof localStorage !== "undefined") {
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key && key.startsWith(prefix)) {
+                    const name = key.substring(prefix.length).split("/")[0];
+                    if (!results.find((r) => r.name === name)) {
+                        results.push({
+                            name,
+                            path: `${path}/${name}`,
+                            size: (localStorage.getItem(key) || "").length,
+                            isFile: () => true,
+                            isDirectory: () => false,
+                        });
+                    }
+                }
+            }
+        }
+        return results;
     }
     async copyFile(source, destination) {
-        throw new Error('copyFile not supported on web');
+        const content = await this.readFile(source);
+        await this.writeFile(destination, content);
     }
     async moveFile(source, destination) {
-        throw new Error('moveFile not supported on web');
+        await this.copyFile(source, destination);
+        await this.deleteFile(source);
     }
 }

package/dist/local-storage/services/StorageWeb.js

@@ -1,26 +1,57 @@
 export class StorageWeb {
     getItem(key) {
-        return localStorage.getItem(key);
+        try {
+            return typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
+        }
+        catch (e) {
+            return null;
+        }
     }
     setItem(key, value) {
-        localStorage.setItem(key, value);
+        try {
+            if (typeof localStorage !== "undefined") {
+                localStorage.setItem(key, value);
+            }
+        }
+        catch (e) {
+            console.warn("[StorageWeb] Failed to set item:", key, e);
+        }
     }
     removeItem(key) {
-        localStorage.removeItem(key);
+        try {
+            if (typeof localStorage !== "undefined") {
+                localStorage.removeItem(key);
+            }
+        }
+        catch (e) {
+            console.warn("[StorageWeb] Failed to remove item:", key, e);
+        }
     }
     clear() {
-        localStorage.clear();
+        try {
+            if (typeof localStorage !== "undefined") {
+                localStorage.clear();
+            }
+        }
+        catch (e) {
+            console.warn("[StorageWeb] Failed to clear storage:", e);
+        }
     }
     getAllKeys() {
-        return Object.keys(localStorage);
+        try {
+            return typeof localStorage !== "undefined" ? Object.keys(localStorage) : [];
+        }
+        catch (e) {
+            return [];
+        }
     }
     multiGet(keys) {
-        return keys.map(key => [key, localStorage.getItem(key)]);
+        return keys.map((key) => [key, this.getItem(key)]);
     }
     multiSet(keyValuePairs) {
-        keyValuePairs.forEach(([key, value]) => localStorage.setItem(key, value));
+        keyValuePairs.forEach(([key, value]) => this.setItem(key, value));
     }
     multiRemove(keys) {
-        keys.forEach(key => localStorage.removeItem(key));
+        keys.forEach((key) => this.removeItem(key));
     }
 }

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

@@ -1,4 +1,4 @@
-import type { ILoggerImplementation } from '../Logger.types';
+import type { ILoggerImplementation } from "../Logger.types";
 export declare class LoggerNative implements ILoggerImplementation {
     logDir: string;
     logFile: string;

package/dist/logger/services/LoggerNative.js

@@ -1,50 +1,48 @@
 // LoggerNative.ts
-import { Platform } from 'react-native';
+import { Platform } from "react-native";
 // Import with null safety
 let RNFS = null;
 let zip = null;
-try {
-    RNFS = require('react-native-fs');
-    if (!RNFS || !RNFS.DocumentDirectoryPath) {
-        console.error('❌ react-native-fs is not properly linked. Please run: cd ios && pod install (iOS) or rebuild your Android app.');
-        RNFS = null;
+if (Platform.OS !== "web") {
+    try {
+        RNFS = require("react-native-fs");
+        if (!RNFS || !RNFS.DocumentDirectoryPath) {
+            console.warn("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('❌ react-native-fs module not found. Please install: npm install 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.warn("react-native-fs module not found.");
+    }
+    try {
+        const zipModule = require("react-native-zip-archive");
+        zip = zipModule.zip;
+    }
+    catch (e) {
+        console.warn("react-native-zip-archive module not found.");
     }
-}
-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.isRotating = false;
         this.isAvailable = false;
-        const dir = 'unvired_logs';
-        const file = 'applog.txt'; // main log file
+        const dir = "unvired_logs";
+        const file = "applog.txt";
         if (!RNFS) {
-            console.warn('⚠️ LoggerNative: RNFS not available, logging to file system disabled');
-            this.logDir = '';
-            this.logFile = '';
-            this.backupZip = '';
+            this.logDir = "";
+            this.logFile = "";
+            this.backupZip = "";
             return;
         }
         this.isAvailable = true;
-        if (Platform.OS === 'android') {
+        if (Platform.OS === "android") {
             this.logDir = `${RNFS.DocumentDirectoryPath}/${dir}`;
         }
-        else if (Platform.OS === 'ios') {
+        else if (Platform.OS === "ios") {
             this.logDir = `${RNFS.LibraryDirectoryPath}/${dir}`;
         }
         else {
-            this.logDir = '';
+            this.logDir = "";
         }
         this.logFile = `${this.logDir}/${file}`;
         this.backupZip = `${this.logDir}/backuplog.zip`;
@@ -56,10 +54,10 @@ export class LoggerNative {
             if (!(await RNFS.exists(this.logDir)))
                 await RNFS.mkdir(this.logDir);
             if (!(await RNFS.exists(this.logFile)))
-                await RNFS.writeFile(this.logFile, '', 'utf8');
+                await RNFS.writeFile(this.logFile, "", "utf8");
         }
         catch (e) {
-            console.error('❌ LoggerNative init error:', e);
+            console.error("LoggerNative init error:", e);
         }
     }
     async writeLine(line, maxSize) {
@@ -67,18 +65,16 @@ export class LoggerNative {
             return;
         try {
             await this.ensureDir();
-            await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
-            // Only check for rotation if not already rotating
+            await RNFS.appendFile(this.logFile, line + "\n", "utf8");
             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);
+            console.error("LoggerNative writeLine error:", e);
         }
     }
     async ensureDir() {
@@ -89,115 +85,80 @@ export class LoggerNative {
                 await RNFS.mkdir(this.logDir);
         }
         catch (e) {
-            console.error('❌ LoggerNative ensureDir error:', 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)');
+            await RNFS.writeFile(this.logFile, "", "utf8");
         }
         catch (e) {
-            console.error('❌ Logger rotation error:', e);
-            // Try to recover by creating a fresh log file if it doesn't exist
+            console.error("Logger rotation error:", e);
             try {
                 if (!(await RNFS.exists(this.logFile))) {
-                    await RNFS.writeFile(this.logFile, '', 'utf8');
-                    console.log('🔧 Recovery: Created fresh log file');
+                    await RNFS.writeFile(this.logFile, "", "utf8");
                 }
             }
-            catch (recoveryError) {
-                console.error('❌ Recovery failed:', recoveryError);
-            }
+            catch (recoveryError) { }
         }
         finally {
-            // Always release the lock
             this.isRotating = false;
         }
     }
-    // ------------------------
-    // Public accessors
-    // ------------------------
     async getLogFileURL() {
         if (!this.isAvailable)
-            return '';
+            return "";
         return this.logFile;
     }
     async getLogFileContent() {
         if (!this.isAvailable || !RNFS)
-            return '';
+            return "";
         try {
             if (await RNFS.exists(this.logFile)) {
-                return await RNFS.readFile(this.logFile, 'utf8');
+                return await RNFS.readFile(this.logFile, "utf8");
             }
-            return '';
+            return "";
         }
         catch (e) {
-            console.error('❌ LoggerNative getLogFileContent error:', e);
-            return '';
+            console.error("LoggerNative getLogFileContent error:", e);
+            return "";
         }
     }
     async getBackupLogFileContent() {
         if (!this.isAvailable || !RNFS)
             return "";
         try {
-            // 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');
+                return await RNFS.readFile(this.backupZip, "base64");
             }
             return "";
         }
         catch (e) {
-            console.error('❌ LoggerNative getBackupLogFileContent error:', e);
+            console.error("LoggerNative getBackupLogFileContent error:", e);
             return "";
         }
     }
@@ -206,12 +167,12 @@ export class LoggerNative {
             return;
         try {
             if (await RNFS.exists(this.logFile))
-                await RNFS.writeFile(this.logFile, '', 'utf8');
+                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);
+            console.error("LoggerNative clear error:", e);
         }
     }
 }

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

@@ -1,8 +1,11 @@
-import type { ILoggerImplementation } from '../Logger.types';
+import type { ILoggerImplementation } from "../Logger.types";
+/**
+ * LoggerWeb - Web implementation using console logging only
+ */
 export declare class LoggerWeb implements ILoggerImplementation {
     logFile: string;
     init(): Promise<void>;
-    writeLine(line: string, maxSize: number): Promise<void>;
+    writeLine(line: string, _maxSize: number): Promise<void>;
     getLogFileURL(): Promise<string>;
     getLogFileContent(): Promise<string>;
     getBackupLogFileContent(): Promise<string>;

package/dist/logger/services/LoggerWeb.js

@@ -1,13 +1,22 @@
+/**
+ * LoggerWeb - Web implementation using console logging only
+ */
 export class LoggerWeb {
     constructor() {
-        this.logFile = '';
+        this.logFile = "";
     }
     async init() { }
-    async writeLine(line, maxSize) {
+    async writeLine(line, _maxSize) {
         console.log(line);
     }
-    async getLogFileURL() { return ''; }
-    async getLogFileContent() { return ''; }
-    async getBackupLogFileContent() { return ""; }
+    async getLogFileURL() {
+        return "";
+    }
+    async getLogFileContent() {
+        return "";
+    }
+    async getBackupLogFileContent() {
+        return "";
+    }
     async clear() { }
 }