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

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

@@ -0,0 +1,336 @@
+let ExpoFS = null;
+try {
+    ExpoFS = require('expo-file-system');
+}
+catch (e) {
+    ExpoFS = null;
+}
+/**
+ * DirectoryReader implementation for Expo
+ */
+class ExpoDirectoryReader {
+    constructor(dirPath) {
+        this.dirPath = dirPath.replace(/\/+$/, '');
+    }
+    readEntries(callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        ExpoFS.readDirectoryAsync(this.dirPath)
+            .then(async (names) => {
+            const entries = [];
+            for (const name of names) {
+                const itemPath = `${this.dirPath}/${name}`;
+                try {
+                    const info = await ExpoFS.getInfoAsync(itemPath);
+                    entries.push(new ExpoFileEntry(itemPath, info.isDirectory));
+                }
+                catch (err) {
+                    entries.push(new ExpoFileEntry(itemPath, false));
+                }
+            }
+            callback(entries);
+        })
+            .catch(errorCallback);
+    }
+}
+/**
+ * FileEntry implementation for Expo
+ */
+class ExpoFileEntry {
+    constructor(path, isDirectory = false) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        this.isDirectory = isDirectory;
+        this.isFile = !isDirectory;
+        // 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(callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        ExpoFS.deleteAsync(targetPath, { idempotent: true })
+            .then(() => callback())
+            .catch(errorCallback);
+    }
+    removeRecursively(callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        ExpoFS.deleteAsync(targetPath, { idempotent: true })
+            .then(() => callback())
+            .catch(errorCallback);
+    }
+    createReader() {
+        return new ExpoDirectoryReader(this.fullPath);
+    }
+    getDirectory(path, options, callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        const basePath = this.fullPath.replace(/\/+$/, '');
+        const relPath = path.replace(/^\/+/, '').replace(/\/+$/, '');
+        const dirPath = `${basePath}/${relPath}`;
+        ExpoFS.getInfoAsync(dirPath)
+            .then((info) => {
+            if (info.exists) {
+                if (info.isDirectory) {
+                    callback(new ExpoFileEntry(dirPath, true));
+                }
+                else {
+                    errorCallback(new Error('Path exists but is not a directory'));
+                }
+            }
+            else if (options.create) {
+                return ExpoFS.makeDirectoryAsync(dirPath, { intermediates: true }).then(() => {
+                    callback(new ExpoFileEntry(dirPath, true));
+                });
+            }
+            else {
+                errorCallback(new Error('Directory does not exist'));
+            }
+        })
+            .catch(errorCallback);
+    }
+    getFile(path, options, callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        const basePath = this.fullPath.replace(/\/+$/, '');
+        const relPath = path.replace(/^\/+/, '');
+        const filePath = `${basePath}/${relPath}`;
+        ExpoFS.getInfoAsync(filePath)
+            .then((info) => {
+            var _a;
+            if (info.exists) {
+                if (!info.isDirectory) {
+                    callback(new ExpoFileEntry(filePath, false));
+                }
+                else {
+                    errorCallback(new Error('Path exists but is a directory'));
+                }
+            }
+            else if (options.create) {
+                return ExpoFS.writeAsStringAsync(filePath, '', { encoding: ((_a = ExpoFS.EncodingType) === null || _a === void 0 ? void 0 : _a.UTF8) || 'utf8' }).then(() => {
+                    callback(new ExpoFileEntry(filePath, false));
+                });
+            }
+            else {
+                errorCallback(new Error('File does not exist'));
+            }
+        })
+            .catch(errorCallback);
+    }
+    file(callback, errorCallback) {
+        if (!ExpoFS) {
+            errorCallback(new Error('expo-file-system is not installed'));
+            return;
+        }
+        const targetPath = this.fullPath.replace(/\/+$/, '');
+        ExpoFS.getInfoAsync(targetPath)
+            .then((info) => {
+            const fileObject = {
+                name: targetPath.split('/').pop() || '',
+                size: info.size || 0,
+                type: '',
+                lastModified: info.modificationTime ? info.modificationTime * 1000 : Date.now(),
+                lastModifiedDate: info.modificationTime ? new Date(info.modificationTime * 1000) : new Date(),
+                path: targetPath,
+            };
+            callback(fileObject);
+        })
+            .catch(errorCallback);
+    }
+    createWriter(callback, errorCallback) {
+        const filePath = this.fullPath.replace(/\/+$/, '');
+        const writer = {
+            filePath: filePath,
+            write: async (data) => {
+                var _a;
+                try {
+                    await ExpoFS.writeAsStringAsync(filePath, data, { encoding: ((_a = ExpoFS.EncodingType) === null || _a === void 0 ? void 0 : _a.UTF8) || 'utf8' });
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                }
+            },
+            append: async (data) => {
+                var _a, _b;
+                try {
+                    let existing = '';
+                    try {
+                        existing = await ExpoFS.readAsStringAsync(filePath, { encoding: ((_a = ExpoFS.EncodingType) === null || _a === void 0 ? void 0 : _a.UTF8) || 'utf8' });
+                    }
+                    catch (e) { }
+                    await ExpoFS.writeAsStringAsync(filePath, existing + data, { encoding: ((_b = ExpoFS.EncodingType) === null || _b === void 0 ? void 0 : _b.UTF8) || 'utf8' });
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                }
+            },
+            truncate: async (size) => {
+                var _a, _b;
+                try {
+                    const content = await ExpoFS.readAsStringAsync(filePath, { encoding: ((_a = ExpoFS.EncodingType) === null || _a === void 0 ? void 0 : _a.UTF8) || 'utf8' });
+                    const truncated = content.substring(0, size);
+                    await ExpoFS.writeAsStringAsync(filePath, truncated, { encoding: ((_b = ExpoFS.EncodingType) === null || _b === void 0 ? void 0 : _b.UTF8) || 'utf8' });
+                    if (writer.onwriteend)
+                        writer.onwriteend();
+                }
+                catch (err) {
+                    if (writer.onerror)
+                        writer.onerror(err);
+                }
+            },
+            seek: (_offset) => {
+                return Promise.resolve();
+            },
+            onwriteend: null,
+            onerror: null
+        };
+        try {
+            callback(writer);
+        }
+        catch (error) {
+            errorCallback(error);
+        }
+    }
+}
+/**
+ * FileSystem implementation for Expo using expo-file-system
+ */
+export class FileSystemExpo {
+    static isAvailable() {
+        return ExpoFS != null && (typeof ExpoFS.documentDirectory === 'string' || typeof ExpoFS.getInfoAsync === 'function');
+    }
+    normalizeEncoding(encoding = 'utf8') {
+        var _a, _b;
+        if (encoding === 'base64') {
+            return ((_a = ExpoFS === null || ExpoFS === void 0 ? void 0 : ExpoFS.EncodingType) === null || _a === void 0 ? void 0 : _a.Base64) || 'base64';
+        }
+        return ((_b = ExpoFS === null || ExpoFS === void 0 ? void 0 : ExpoFS.EncodingType) === null || _b === void 0 ? void 0 : _b.UTF8) || 'utf8';
+    }
+    getDocDir() {
+        const docDir = (ExpoFS === null || ExpoFS === void 0 ? void 0 : ExpoFS.documentDirectory) || '';
+        return docDir.replace(/^file:\/\//, '').replace(/\/$/, '');
+    }
+    getDocumentDirectory() {
+        return this.getDocDir();
+    }
+    async resolveLocalFileSystemURL(url) {
+        if (!ExpoFS) {
+            throw new Error('expo-file-system is not installed');
+        }
+        let cleanPath = url.replace(/^file:\/\//, '');
+        try {
+            cleanPath = decodeURIComponent(cleanPath);
+        }
+        catch (e) { }
+        cleanPath = cleanPath.replace(/\/+/g, '/').replace(/\/+$/, '');
+        const info = await ExpoFS.getInfoAsync(cleanPath);
+        if (!info.exists) {
+            throw new Error(`Path does not exist: ${cleanPath}`);
+        }
+        return new ExpoFileEntry(cleanPath, info.isDirectory);
+    }
+    async getFolderBasedOnUserId(userId) {
+        const userPath = `${this.getDocDir()}/${userId}`;
+        const info = await ExpoFS.getInfoAsync(userPath);
+        if (!info.exists) {
+            await ExpoFS.makeDirectoryAsync(userPath, { intermediates: true });
+        }
+        // Return native URL with trailing slash!
+        return `file://${userPath}/`;
+    }
+    async deleteUserFolder(userId) {
+        const userPath = `${this.getDocDir()}/${userId}`;
+        const info = await ExpoFS.getInfoAsync(userPath);
+        if (info.exists) {
+            await ExpoFS.deleteAsync(userPath, { idempotent: true });
+        }
+    }
+    async createDirectory(path) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        const info = await ExpoFS.getInfoAsync(cleanPath);
+        if (!info.exists) {
+            await ExpoFS.makeDirectoryAsync(cleanPath, { intermediates: true });
+        }
+    }
+    async readFile(path, encoding = 'utf8') {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        return await ExpoFS.readAsStringAsync(cleanPath, { encoding: this.normalizeEncoding(encoding) });
+    }
+    async writeFile(path, content, encoding = 'utf8') {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        await ExpoFS.writeAsStringAsync(cleanPath, content, { encoding: this.normalizeEncoding(encoding) });
+    }
+    async deleteFile(path) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        const info = await ExpoFS.getInfoAsync(cleanPath);
+        if (info.exists) {
+            await ExpoFS.deleteAsync(cleanPath, { idempotent: true });
+        }
+    }
+    async exists(path) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        const info = await ExpoFS.getInfoAsync(cleanPath);
+        return Boolean(info.exists);
+    }
+    async stat(path) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        const info = await ExpoFS.getInfoAsync(cleanPath);
+        return {
+            size: info.size || 0,
+            mtime: info.modificationTime ? new Date(info.modificationTime * 1000) : new Date(),
+            isDirectory: () => Boolean(info.isDirectory),
+            isFile: () => !Boolean(info.isDirectory),
+            path: cleanPath
+        };
+    }
+    async readDir(path) {
+        const cleanPath = path.replace(/^file:\/\//, '').replace(/\/+$/, '');
+        const names = await ExpoFS.readDirectoryAsync(cleanPath);
+        const results = [];
+        for (const name of names) {
+            const itemPath = `${cleanPath}/${name}`;
+            const info = await ExpoFS.getInfoAsync(itemPath);
+            results.push({
+                name: name,
+                path: itemPath,
+                size: info.size || 0,
+                mtime: info.modificationTime ? new Date(info.modificationTime * 1000) : new Date(),
+                isDirectory: () => Boolean(info.isDirectory),
+                isFile: () => !Boolean(info.isDirectory)
+            });
+        }
+        return results;
+    }
+    async copyFile(source, destination) {
+        await ExpoFS.copyAsync({
+            from: source.replace(/^file:\/\//, '').replace(/\/+$/, ''),
+            to: destination.replace(/^file:\/\//, '').replace(/\/+$/, '')
+        });
+    }
+    async moveFile(source, destination) {
+        await ExpoFS.moveAsync({
+            from: source.replace(/^file:\/\//, '').replace(/\/+$/, ''),
+            to: destination.replace(/^file:\/\//, '').replace(/\/+$/, '')
+        });
+    }
+}

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

@@ -1,6 +1,27 @@
-import * as RNFS from 'react-native-fs';
 import type { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem';
+export interface RNFSStatResult {
+    name?: string;
+    path: string;
+    size: number;
+    mode?: number;
+    ctime?: number;
+    mtime?: number | Date;
+    originalFilepath?: string;
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+}
+export interface RNFSReadDirItem {
+    name: string;
+    path: string;
+    size: number;
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+}
 export declare class FileSystemNative implements IFileSystem {
+    /**
+     * Check if react-native-fs is available in runtime
+     */
+    static isAvailable(): boolean;
     getDocumentDirectory(): string;
     resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
     getFolderBasedOnUserId(userId: string): Promise<string>;
@@ -10,8 +31,8 @@ export declare class FileSystemNative implements IFileSystem {
     writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
     deleteFile(path: string): Promise<void>;
     exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<RNFS.StatResult>;
-    readDir(path: string): Promise<RNFS.ReadDirItem[]>;
+    stat(path: string): Promise<RNFSStatResult>;
+    readDir(path: string): Promise<RNFSReadDirItem[]>;
     copyFile(source: string, destination: string): Promise<void>;
     moveFile(source: string, destination: string): Promise<void>;
 }