@unvired/react-native-unvired-sdk 0.0.45 → 0.0.46

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

@@ -1,16 +1,26 @@
-import * as RNFS from 'react-native-fs';
+let RNFS = null;
+try {
+    RNFS = require('react-native-fs');
+}
+catch (e) {
+    RNFS = null;
+}
 /**
  * DirectoryReader implementation for React Native
  * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
  */
 class RNDirectoryReader {
     constructor(dirPath) {
-        this.dirPath = dirPath;
+        this.dirPath = dirPath.replace(/\/+$/, '');
     }
     readEntries(callback, errorCallback) {
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
         RNFS.readDir(this.dirPath)
-            .then(items => {
-            const entries = items.map(item => new RNFileEntry(item.path, item.isDirectory()));
+            .then((items) => {
+            const entries = items.map((item) => new RNFileEntry(item.path, item.isDirectory()));
             callback(entries);
         })
             .catch(errorCallback);
@@ -22,18 +32,25 @@ class RNDirectoryReader {
  */
 class RNFileEntry {
     constructor(path, isDirectory = false) {
-        this.fullPath = path;
-        this.nativeURL = `file://${path}`;
+        const cleanPath = path.replace(/\/+$/, '');
         this.isDirectory = isDirectory;
         this.isFile = !isDirectory;
-        this.name = path.split('/').pop() || '';
+        // Cordova spec: directories must end with trailing slash in fullPath and nativeURL
+        this.fullPath = isDirectory ? `${cleanPath}/` : cleanPath;
+        this.nativeURL = `file://${this.fullPath}`;
+        this.name = cleanPath.split('/').pop() || '';
         this.filesystem = null;
     }
     /**
      * Remove a file or empty directory
      */
     remove(callback, errorCallback) {
-        RNFS.unlink(this.fullPath)
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        RNFS.unlink(targetPath)
             .then(() => callback())
             .catch(errorCallback);
     }
@@ -41,8 +58,12 @@ class RNFileEntry {
      * Remove a directory and all its contents recursively
      */
     removeRecursively(callback, errorCallback) {
-        // RNFS.unlink works recursively for directories
-        RNFS.unlink(this.fullPath)
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        RNFS.unlink(targetPath)
             .then(() => callback())
             .catch(errorCallback);
     }
@@ -56,11 +77,17 @@ class RNFileEntry {
      * Get or create a subdirectory
      */
     getDirectory(path, options, callback, errorCallback) {
-        const dirPath = `${this.fullPath}/${path}`;
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
+        const basePath = this.fullPath.replace(/\/+$/, '');
+        const relPath = path.replace(/^\/+/, '').replace(/\/+$/, '');
+        const dirPath = `${basePath}/${relPath}`;
         RNFS.exists(dirPath)
-            .then(exists => {
+            .then((exists) => {
             if (exists) {
-                return RNFS.stat(dirPath).then(stats => {
+                return RNFS.stat(dirPath).then((stats) => {
                     if (stats.isDirectory()) {
                         callback(new RNFileEntry(dirPath, true));
                     }
@@ -84,11 +111,17 @@ class RNFileEntry {
      * Get or create a file
      */
     getFile(path, options, callback, errorCallback) {
-        const filePath = `${this.fullPath}/${path}`;
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
+        const basePath = this.fullPath.replace(/\/+$/, '');
+        const relPath = path.replace(/^\/+/, '');
+        const filePath = `${basePath}/${relPath}`;
         RNFS.exists(filePath)
-            .then(exists => {
+            .then((exists) => {
             if (exists) {
-                return RNFS.stat(filePath).then(stats => {
+                return RNFS.stat(filePath).then((stats) => {
                     if (!stats.isDirectory()) {
                         callback(new RNFileEntry(filePath, false));
                     }
@@ -113,16 +146,21 @@ class RNFileEntry {
      * Get file metadata
      */
     file(callback, errorCallback) {
-        RNFS.stat(this.fullPath)
-            .then(stats => {
+        if (!RNFS) {
+            errorCallback(new Error('react-native-fs is not available'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        RNFS.stat(targetPath)
+            .then((stats) => {
             // Create a File-like object with metadata
             const fileObject = {
-                name: this.fullPath.split('/').pop() || '',
+                name: targetPath.split('/').pop() || '',
                 size: stats.size,
                 type: '', // RNFS doesn't provide MIME type directly
                 lastModified: new Date(stats.mtime).getTime(),
                 lastModifiedDate: new Date(stats.mtime),
-                path: this.fullPath,
+                path: targetPath,
             };
             callback(fileObject);
         })
@@ -132,29 +170,35 @@ class RNFileEntry {
      * Create a file writer for writing to the file
      */
     createWriter(callback, errorCallback) {
-        // Create a FileWriter-like object
+        const filePath = this.fullPath.replace(/\/+$/, '');
         const writer = {
-            filePath: this.fullPath,
+            filePath: filePath,
             write: (data) => {
-                return RNFS.writeFile(this.fullPath, data, 'utf8')
+                if (!RNFS)
+                    return Promise.reject(new Error('react-native-fs is not available'));
+                return RNFS.writeFile(filePath, data, 'utf8')
                     .then(() => { if (writer.onwriteend)
                     writer.onwriteend(); })
                     .catch((err) => { if (writer.onerror)
                     writer.onerror(err); });
             },
             append: (data) => {
-                return RNFS.appendFile(this.fullPath, data, 'utf8')
+                if (!RNFS)
+                    return Promise.reject(new Error('react-native-fs is not available'));
+                return RNFS.appendFile(filePath, data, 'utf8')
                     .then(() => { if (writer.onwriteend)
                     writer.onwriteend(); })
                     .catch((err) => { if (writer.onerror)
                     writer.onerror(err); });
             },
             truncate: (size) => {
+                if (!RNFS)
+                    return Promise.reject(new Error('react-native-fs is not available'));
                 // Read file, truncate content, and write back
-                return RNFS.readFile(this.fullPath, 'utf8')
-                    .then(content => {
+                return RNFS.readFile(filePath, 'utf8')
+                    .then((content) => {
                     const truncated = content.substring(0, size);
-                    return RNFS.writeFile(this.fullPath, truncated, 'utf8')
+                    return RNFS.writeFile(filePath, truncated, 'utf8')
                         .then(() => { if (writer.onwriteend)
                         writer.onwriteend(); });
                 })
@@ -162,8 +206,6 @@ class RNFileEntry {
                     writer.onerror(err); });
             },
             seek: (offset) => {
-                // Not directly supported in RNFS
-                // This would need to be implemented with read/write operations
                 return Promise.resolve();
             },
             onwriteend: null,
@@ -178,20 +220,35 @@ class RNFileEntry {
     }
 }
 export class FileSystemNative {
+    /**
+     * Check if react-native-fs is available in runtime
+     */
+    static isAvailable() {
+        return !!RNFS && !!RNFS.DocumentDirectoryPath;
+    }
     getDocumentDirectory() {
-        return RNFS.DocumentDirectoryPath;
+        return (RNFS === null || RNFS === void 0 ? void 0 : RNFS.DocumentDirectoryPath) || '';
     }
     async resolveLocalFileSystemURL(url) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         return new Promise((resolve, reject) => {
-            // Remove file:// prefix if present
-            const path = url.replace('file://', '');
+            // Remove file:// prefix, decode URI components if encoded, and normalize multiple slashes
+            let path = url.replace(/^file:\/\//, '');
+            try {
+                path = decodeURIComponent(path);
+            }
+            catch (e) { }
+            // Normalize internal multiple slashes to single slash, and strip trailing slash for RNFS.stat/exists
+            path = path.replace(/\/+/g, '/').replace(/\/+$/, '');
             RNFS.exists(path)
-                .then(exists => {
+                .then((exists) => {
                 if (!exists) {
                     reject(new Error(`Path does not exist: ${path}`));
                     return;
                 }
-                return RNFS.stat(path).then(stats => {
+                return RNFS.stat(path).then((stats) => {
                     resolve(new RNFileEntry(path, stats.isDirectory()));
                 });
             })
@@ -199,6 +256,9 @@ export class FileSystemNative {
         });
     }
     async getFolderBasedOnUserId(userId) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         const userPath = `${RNFS.DocumentDirectoryPath}/${userId}`;
         try {
             const exists = await RNFS.exists(userPath);
@@ -206,14 +266,18 @@ export class FileSystemNative {
                 // Create the directory if it doesn't exist
                 await RNFS.mkdir(userPath);
             }
-            // Return the native URL format
-            return `file://${userPath}`;
+            // Return the native URL format with trailing slash!
+            // Crucial: Core SDK appends 'Attachment/' or 'Inbox/' without a leading slash.
+            return `file://${userPath}/`;
         }
         catch (error) {
             throw new Error(`Failed to get/create folder for user ${userId}: ${error}`);
         }
     }
     async deleteUserFolder(userId) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         const userPath = `${RNFS.DocumentDirectoryPath}/${userId}`;
         try {
             const exists = await RNFS.exists(userPath);
@@ -227,36 +291,63 @@ export class FileSystemNative {
         }
     }
     async createDirectory(path) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         const exists = await RNFS.exists(path);
         if (!exists) {
             await RNFS.mkdir(path);
         }
     }
     async readFile(path, encoding = 'utf8') {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         return await RNFS.readFile(path, encoding);
     }
     async writeFile(path, content, encoding = 'utf8') {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         await RNFS.writeFile(path, content, encoding);
     }
     async deleteFile(path) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         const exists = await RNFS.exists(path);
         if (exists) {
             await RNFS.unlink(path);
         }
     }
     async exists(path) {
+        if (!RNFS) {
+            return false;
+        }
         return await RNFS.exists(path);
     }
     async stat(path) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         return await RNFS.stat(path);
     }
     async readDir(path) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         return await RNFS.readDir(path);
     }
     async copyFile(source, destination) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         await RNFS.copyFile(source, destination);
     }
     async moveFile(source, destination) {
+        if (!RNFS) {
+            throw new Error('react-native-fs is not available');
+        }
         await RNFS.moveFile(source, destination);
     }
 }

package/dist/file-system/services/FileSystemWeb.d.ts

@@ -1,6 +1,6 @@
 import type { IFileEntry, IFileSystem, FileSystemEncoding } from "../FileSystem";
 /**
- * FileSystemWeb - Virtual browser-backed file system with localStorage persistence
+ * FileSystem implementation for Web using localStorage
  */
 export declare class FileSystemWeb implements IFileSystem {
     private baseDir;

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

@@ -1,26 +1,26 @@
 class WebDirectoryReader {
-    constructor(fullPath) {
-        this.fullPath = fullPath;
+    constructor(dirPath) {
+        this.dirPath = dirPath.replace(/\/+$/, "");
     }
-    readEntries(successCallback, errorCallback) {
+    readEntries(callback, errorCallback) {
         try {
             const entries = [];
-            const prefix = `__vfs_${this.fullPath}/`;
+            const prefix = `__vfs_${this.dirPath}/`;
             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));
+                        const name = relPath.split("/")[0];
+                        const fullPath = `${this.dirPath}/${name}`;
+                        if (!entries.find((e) => e.name === name)) {
+                            const isDir = relPath.includes("/");
+                            entries.push(new WebFileEntry(fullPath, isDir));
                         }
                     }
                 }
             }
-            successCallback(entries);
+            callback(entries);
         }
         catch (e) {
             errorCallback(e);
@@ -29,16 +29,19 @@ class WebDirectoryReader {
 }
 class WebFileEntry {
     constructor(fullPath, isDirectory) {
-        this.fullPath = fullPath.replace(/\/+/g, "/");
-        this.name = this.fullPath.split("/").filter(Boolean).pop() || "root";
+        const cleanPath = fullPath.replace(/\/+/g, "/").replace(/\/+$/, "");
+        this.name = cleanPath.split("/").filter(Boolean).pop() || "root";
         this.isFile = !isDirectory;
         this.isDirectory = isDirectory;
+        // Cordova spec: directories must end with trailing slash in fullPath and nativeURL
+        this.fullPath = isDirectory ? `${cleanPath}/` : cleanPath;
         this.nativeURL = `file://${this.fullPath}`;
     }
     remove(callback, errorCallback) {
         try {
             if (typeof localStorage !== "undefined") {
-                localStorage.removeItem(`__vfs_${this.fullPath}`);
+                const targetPath = this.fullPath.replace(/\/+$/, "");
+                localStorage.removeItem(`__vfs_${targetPath}`);
             }
             callback();
         }
@@ -49,7 +52,8 @@ class WebFileEntry {
     removeRecursively(callback, errorCallback) {
         try {
             if (typeof localStorage !== "undefined") {
-                const prefix = `__vfs_${this.fullPath}`;
+                const targetPath = this.fullPath.replace(/\/+$/, "");
+                const prefix = `__vfs_${targetPath}`;
                 const keysToRemove = [];
                 for (let i = 0; i < localStorage.length; i++) {
                     const key = localStorage.key(i);
@@ -69,96 +73,71 @@ class WebFileEntry {
         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 }));
+        const basePath = this.fullPath.replace(/\/+$/, "");
+        const relPath = path.replace(/^\/+/, "").replace(/\/+$/, "");
+        const dirPath = `${basePath}/${relPath}`;
+        if (options.create) {
+            if (typeof localStorage !== "undefined") {
+                localStorage.setItem(`__vfs_${dirPath}`, JSON.stringify({ isDir: true }));
+            }
         }
-        callback(entry);
+        callback(new WebFileEntry(dirPath, true));
     }
     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 basePath = this.fullPath.replace(/\/+$/, "");
+        const relPath = path.replace(/^\/+/, "");
+        const filePath = `${basePath}/${relPath}`;
+        if (options.create) {
+            if (typeof localStorage !== "undefined") {
+                if (localStorage.getItem(`__vfs_${filePath}`) === null) {
+                    localStorage.setItem(`__vfs_${filePath}`, "");
+                }
             }
         }
-        const entry = new WebFileEntry(filePath, false);
-        callback(entry);
+        callback(new WebFileEntry(filePath, false));
     }
     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);
+            const targetPath = this.fullPath.replace(/\/+$/, "");
+            const content = typeof localStorage !== "undefined"
+                ? localStorage.getItem(`__vfs_${targetPath}`) || ""
+                : "";
+            const blob = new Blob([content], { type: "text/plain" });
+            callback(blob);
         }
         catch (e) {
             errorCallback(e);
         }
     }
     createWriter(callback, errorCallback) {
-        const filePath = this.fullPath;
+        const filePath = this.fullPath.replace(/\/+$/, "");
         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) => {
+            write: (blob) => {
                 try {
-                    if (typeof localStorage !== "undefined") {
-                        const existing = localStorage.getItem(`__vfs_${filePath}`) || "";
-                        localStorage.setItem(`__vfs_${filePath}`, existing + data);
+                    if (blob instanceof Blob) {
+                        const reader = new FileReader();
+                        reader.onloadend = () => {
+                            if (typeof localStorage !== "undefined") {
+                                localStorage.setItem(`__vfs_${filePath}`, reader.result);
+                            }
+                            if (writer.onwriteend)
+                                writer.onwriteend();
+                        };
+                        reader.readAsText(blob);
                     }
-                    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));
+                    else {
+                        if (typeof localStorage !== "undefined") {
+                            localStorage.setItem(`__vfs_${filePath}`, String(blob));
+                        }
+                        if (writer.onwriteend)
+                            writer.onwriteend();
                     }
-                    if (writer.onwriteend)
-                        writer.onwriteend();
-                    return Promise.resolve();
                 }
-                catch (err) {
+                catch (e) {
                     if (writer.onerror)
-                        writer.onerror(err);
-                    return Promise.reject(err);
+                        writer.onerror(e);
                 }
             },
-            seek: () => Promise.resolve(),
             onwriteend: null,
             onerror: null,
         };
@@ -166,23 +145,29 @@ class WebFileEntry {
     }
 }
 /**
- * FileSystemWeb - Virtual browser-backed file system with localStorage persistence
+ * FileSystem implementation for Web using localStorage
  */
 export class FileSystemWeb {
     constructor() {
-        this.baseDir = "/virtual-fs";
+        this.baseDir = "/unvired_app_fs";
     }
     getDocumentDirectory() {
         return this.baseDir;
     }
     async resolveLocalFileSystemURL(url) {
-        const path = url.replace(/^file:\/\//, "");
+        let path = url.replace(/^file:\/\//, "");
+        try {
+            path = decodeURIComponent(path);
+        }
+        catch (e) { }
+        path = path.replace(/\/+/g, "/").replace(/\/+$/, "");
         return new WebFileEntry(path, false);
     }
     async getFolderBasedOnUserId(userId) {
         const folder = `${this.baseDir}/users/${userId}`;
         await this.createDirectory(folder);
-        return `file://${folder}`;
+        // Return native URL with trailing slash!
+        return `file://${folder}/`;
     }
     async deleteUserFolder(userId) {
         const prefix = `__vfs_${this.baseDir}/users/${userId}`;
@@ -198,38 +183,44 @@ export class FileSystemWeb {
         }
     }
     async createDirectory(path) {
+        const cleanPath = path.replace(/\/+$/, "");
         if (typeof localStorage !== "undefined") {
-            localStorage.setItem(`__vfs_${path}`, JSON.stringify({ isDir: true }));
+            localStorage.setItem(`__vfs_${cleanPath}`, JSON.stringify({ isDir: true }));
         }
     }
     async readFile(path, encoding = "utf8") {
+        const cleanPath = path.replace(/\/+$/, "");
         if (typeof localStorage !== "undefined") {
-            const val = localStorage.getItem(`__vfs_${path}`);
+            const val = localStorage.getItem(`__vfs_${cleanPath}`);
             if (val !== null)
                 return val;
         }
         throw new Error(`File not found: ${path}`);
     }
     async writeFile(path, content, encoding = "utf8") {
+        const cleanPath = path.replace(/\/+$/, "");
         if (typeof localStorage !== "undefined") {
-            localStorage.setItem(`__vfs_${path}`, content);
+            localStorage.setItem(`__vfs_${cleanPath}`, content);
         }
     }
     async deleteFile(path) {
+        const cleanPath = path.replace(/\/+$/, "");
         if (typeof localStorage !== "undefined") {
-            localStorage.removeItem(`__vfs_${path}`);
+            localStorage.removeItem(`__vfs_${cleanPath}`);
         }
     }
     async exists(path) {
+        const cleanPath = path.replace(/\/+$/, "");
         if (typeof localStorage !== "undefined") {
-            return localStorage.getItem(`__vfs_${path}`) !== null;
+            return localStorage.getItem(`__vfs_${cleanPath}`) !== null;
         }
         return false;
     }
     async stat(path) {
+        const cleanPath = path.replace(/\/+$/, "");
         let size = 0;
         if (typeof localStorage !== "undefined") {
-            const val = localStorage.getItem(`__vfs_${path}`);
+            const val = localStorage.getItem(`__vfs_${cleanPath}`);
             if (val !== null)
                 size = val.length;
         }
@@ -242,7 +233,8 @@ export class FileSystemWeb {
         };
     }
     async readDir(path) {
-        const prefix = `__vfs_${path}/`;
+        const cleanPath = path.replace(/\/+$/, "");
+        const prefix = `__vfs_${cleanPath}/`;
         const results = [];
         if (typeof localStorage !== "undefined") {
             for (let i = 0; i < localStorage.length; i++) {
@@ -252,7 +244,7 @@ export class FileSystemWeb {
                     if (!results.find((r) => r.name === name)) {
                         results.push({
                             name,
-                            path: `${path}/${name}`,
+                            path: `${cleanPath}/${name}`,
                             size: (localStorage.getItem(key) || "").length,
                             isFile: () => true,
                             isDirectory: () => false,

package/dist/local-storage/services/StorageNative.d.ts

@@ -1,4 +1,5 @@
 export declare class StorageNative {
+    static isMMKVAvailable(): boolean;
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
     removeItem(key: string): void;