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

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

@@ -1,9 +1,63 @@
-import { BaseFileSystem } from './BaseFileSystem';
+import { IFileEntry, FileSystemEncoding } from './FileSystem.types';
 /**
  * FileSystem class
- * Extends BaseFileSystem
+ * Handles file system operations for React Native
+ * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
+ * - Web: Limited functionality (not supported)
  */
-export declare class FileSystem extends BaseFileSystem {
+export declare class FileSystem {
+    /**
+     * 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?: FileSystemEncoding): Promise<string>;
+    /**
+     * Write file content
+     */
+    static writeFile(path: string, content: string, encoding?: FileSystemEncoding): 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<any>;
+    /**
+     * List directory contents
+     */
+    static readDir(path: string): Promise<any[]>;
+    /**
+     * Copy file
+     */
+    static copyFile(source: string, destination: string): Promise<void>;
+    /**
+     * Move file
+     */
+    static moveFile(source: string, destination: string): Promise<void>;
 }
 export type { IFileEntry } from './FileSystem.types';
 export default FileSystem;

package/dist/file-system/FileSystem.js

@@ -1,11 +1,164 @@
-// FileSystem.ts
-// Main file system export
-import { BaseFileSystem } from './BaseFileSystem';
+import { Platform } from 'react-native';
+import { FileSystemNative } from './services/FileSystemNative';
+import { FileSystemWeb } from './services/FileSystemWeb';
+// Select file system implementation based on platform
+const fsImpl = Platform.OS === 'web' ? new FileSystemWeb() : new FileSystemNative();
 /**
  * FileSystem class
- * Extends BaseFileSystem
+ * Handles file system operations for React Native
+ * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
+ * - Web: Limited functionality (not supported)
  */
-export class FileSystem extends BaseFileSystem {
+export class FileSystem {
+    /**
+     * Get document directory path
+     */
+    static getDocumentDirectory() {
+        return fsImpl.getDocumentDirectory();
+    }
+    /**
+     * Resolve local file system URL
+     */
+    static async resolveLocalFileSystemURL(url) {
+        try {
+            return await fsImpl.resolveLocalFileSystemURL(url);
+        }
+        catch (error) {
+            console.error('Error resolving file system URL:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get folder based on user ID
+     */
+    static async getFolderBasedOnUserId(userId) {
+        try {
+            return await fsImpl.getFolderBasedOnUserId(userId);
+        }
+        catch (error) {
+            console.error('Error getting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete user folder
+     */
+    static async deleteUserFolder(userId) {
+        try {
+            await fsImpl.deleteUserFolder(userId);
+        }
+        catch (error) {
+            console.error('Error deleting user folder:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create directory
+     */
+    static async createDirectory(path) {
+        try {
+            await fsImpl.createDirectory(path);
+        }
+        catch (error) {
+            console.error('Error creating directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Read file content
+     */
+    static async readFile(path, encoding = 'utf8') {
+        try {
+            return await fsImpl.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 fsImpl.writeFile(path, content, encoding);
+        }
+        catch (error) {
+            console.error('Error writing file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete file
+     */
+    static async deleteFile(path) {
+        try {
+            await fsImpl.deleteFile(path);
+        }
+        catch (error) {
+            console.error('Error deleting file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if file exists
+     */
+    static async exists(path) {
+        try {
+            return await fsImpl.exists(path);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get file info
+     */
+    static async stat(path) {
+        try {
+            return await fsImpl.stat(path);
+        }
+        catch (error) {
+            console.error('Error getting file stats:', error);
+            throw error;
+        }
+    }
+    /**
+     * List directory contents
+     */
+    static async readDir(path) {
+        try {
+            return await fsImpl.readDir(path);
+        }
+        catch (error) {
+            console.error('Error reading directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Copy file
+     */
+    static async copyFile(source, destination) {
+        try {
+            await fsImpl.copyFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error copying file:', error);
+            throw error;
+        }
+    }
+    /**
+     * Move file
+     */
+    static async moveFile(source, destination) {
+        try {
+            await fsImpl.moveFile(source, destination);
+        }
+        catch (error) {
+            console.error('Error moving file:', error);
+            throw error;
+        }
+    }
 }
 // Default export
 export default FileSystem;

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

@@ -1,11 +1,41 @@
 /**
  * File entry interface
  */
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
 export interface IFileEntry {
     isFile: boolean;
     isDirectory: boolean;
     name: string;
     fullPath: string;
     filesystem?: any;
-    nativeURL?: string;
+    nativeURL: string;
+    remove(callback: () => void, errorCallback: (error: any) => void): void;
+    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
+    createReader(): IDirectoryReader;
+    getDirectory?(path: string, options: {
+        create: boolean;
+    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    getFile?(path: string, options: {
+        create: boolean;
+    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    file?(callback: (file: any) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+export type FileSystemEncoding = 'utf8' | 'ascii' | 'base64';
+export interface IFileSystem {
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<any>;
+    readDir(path: string): Promise<any[]>;
+    copyFile(source: string, destination: string): Promise<void>;
+    moveFile(source: string, destination: string): Promise<void>;
 }

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

@@ -0,0 +1,26 @@
+import { IFileEntry, IDirectoryReader } from './FileSystem.types';
+export declare class RNFileEntry implements IFileEntry {
+    isFile: boolean;
+    isDirectory: boolean;
+    name: string;
+    fullPath: string;
+    nativeURL: string;
+    filesystem: any;
+    constructor(isFile: boolean, isDirectory: boolean, name: string, fullPath: string, nativeURL: string, filesystem?: any);
+    remove(successCallback: () => void, errorCallback: (error: any) => void): void;
+    removeRecursively(successCallback: () => void, errorCallback: (error: any) => void): void;
+    createReader(): IDirectoryReader;
+    getDirectory(path: string, options: {
+        create: boolean;
+    }, successCallback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    getFile(path: string, options: {
+        create: boolean;
+    }, successCallback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    file(callback: (file: any) => void, errorCallback: (error: any) => void): void;
+    createWriter(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+export declare class RNDirectoryReader implements IDirectoryReader {
+    private localPath;
+    constructor(localPath: string);
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}

package/dist/file-system/RNFileEntry.js

@@ -0,0 +1,114 @@
+import * as RNFS from '@dr.pogodin/react-native-fs';
+export class RNFileEntry {
+    constructor(isFile, isDirectory, name, fullPath, nativeURL, filesystem = null) {
+        this.isFile = isFile;
+        this.isDirectory = isDirectory;
+        this.name = name;
+        this.fullPath = fullPath;
+        this.nativeURL = nativeURL;
+        this.filesystem = filesystem;
+    }
+    remove(successCallback, errorCallback) {
+        RNFS.unlink(this.fullPath)
+            .then(() => successCallback())
+            .catch((err) => errorCallback(err));
+    }
+    removeRecursively(successCallback, errorCallback) {
+        this.remove(successCallback, errorCallback);
+    }
+    createReader() {
+        return new RNDirectoryReader(this.fullPath);
+    }
+    getDirectory(path, options, successCallback, errorCallback) {
+        const newPath = this.fullPath + (this.fullPath.endsWith('/') ? '' : '/') + path;
+        const newNativeURL = "file://" + newPath;
+        if (options.create) {
+            RNFS.mkdir(newPath).then(() => {
+                successCallback(new RNFileEntry(false, true, path, newPath, newNativeURL));
+            }).catch(errorCallback);
+        }
+        else {
+            RNFS.stat(newPath).then(stat => {
+                if (stat.isDirectory()) {
+                    successCallback(new RNFileEntry(false, true, path, newPath, newNativeURL));
+                }
+                else {
+                    errorCallback("Not a directory");
+                }
+            }).catch(errorCallback);
+        }
+    }
+    getFile(path, options, successCallback, errorCallback) {
+        const newPath = this.fullPath + (this.fullPath.endsWith('/') ? '' : '/') + path;
+        const newNativeURL = "file://" + newPath;
+        if (options.create) {
+            RNFS.exists(newPath).then(exists => {
+                if (exists) {
+                    successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
+                }
+                else {
+                    RNFS.writeFile(newPath, '', 'utf8').then(() => {
+                        successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
+                    }).catch(errorCallback);
+                }
+            }).catch(errorCallback);
+        }
+        else {
+            RNFS.stat(newPath).then(stat => {
+                if (stat.isFile()) {
+                    successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
+                }
+                else {
+                    errorCallback("Not a file");
+                }
+            }).catch(errorCallback);
+        }
+    }
+    file(callback, errorCallback) {
+        RNFS.stat(this.fullPath).then(stat => {
+            const file = {
+                name: stat.name,
+                localURL: "file://" + stat.path,
+                type: "",
+                lastModified: stat.mtime ? new Date(stat.mtime).getTime() : 0,
+                lastModifiedDate: stat.mtime,
+                size: stat.size,
+                start: 0,
+                end: stat.size,
+                slice: () => { }
+            };
+            callback(file);
+        }).catch(errorCallback);
+    }
+    createWriter(callback, errorCallback) {
+        const writer = {
+            write: (data) => {
+                RNFS.writeFile(this.fullPath, data, 'utf8')
+                    .then(() => { if (writer.onwriteend)
+                    writer.onwriteend(); })
+                    .catch((err) => { if (writer.onerror)
+                    writer.onerror(err); });
+            },
+            seek: () => { },
+            truncate: () => { },
+            onwriteend: null,
+            onerror: null
+        };
+        callback(writer);
+    }
+}
+export class RNDirectoryReader {
+    constructor(localPath) {
+        this.localPath = localPath;
+    }
+    readEntries(successCallback, errorCallback) {
+        RNFS.readDir(this.localPath)
+            .then((result) => {
+            const entries = result.map(fileStat => {
+                return new RNFileEntry(fileStat.isFile(), fileStat.isDirectory(), fileStat.name || fileStat.path.split('/').pop() || '', fileStat.path, "file://" + fileStat.path);
+            });
+            successCallback(entries);
+        })
+            .catch((err) => errorCallback(err));
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import * as RNFS from '@dr.pogodin/react-native-fs';
+import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+export declare class FileSystemNative implements IFileSystem {
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<RNFS.StatResultT>;
+    readDir(path: string): Promise<RNFS.ReadDirResItemT[]>;
+    copyFile(source: string, destination: string): Promise<void>;
+    moveFile(source: string, destination: string): Promise<void>;
+}

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

@@ -0,0 +1,68 @@
+import * as RNFS from '@dr.pogodin/react-native-fs';
+import { RNFileEntry } from '../RNFileEntry';
+export class FileSystemNative {
+    getDocumentDirectory() {
+        return RNFS.DocumentDirectoryPath;
+    }
+    async resolveLocalFileSystemURL(url) {
+        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);
+        const fileName = stat.name || normalizedPath.split('/').pop() || 'unknown';
+        return new RNFileEntry(stat.isFile(), stat.isDirectory(), fileName, stat.path, `file://${stat.path}`);
+    }
+    async getFolderBasedOnUserId(userId) {
+        const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
+        const exists = await RNFS.exists(userFolder);
+        if (!exists) {
+            await RNFS.mkdir(userFolder, { NSURLIsExcludedFromBackupKey: true });
+        }
+        return userFolder;
+    }
+    async deleteUserFolder(userId) {
+        const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
+        const exists = await RNFS.exists(userFolder);
+        if (exists) {
+            await RNFS.unlink(userFolder);
+        }
+    }
+    async createDirectory(path) {
+        const exists = await RNFS.exists(path);
+        if (!exists) {
+            await RNFS.mkdir(path);
+        }
+    }
+    async readFile(path, encoding = 'utf8') {
+        return await RNFS.readFile(path, encoding);
+    }
+    async writeFile(path, content, encoding = 'utf8') {
+        await RNFS.writeFile(path, content, encoding);
+    }
+    async deleteFile(path) {
+        const exists = await RNFS.exists(path);
+        if (exists) {
+            await RNFS.unlink(path);
+        }
+    }
+    async exists(path) {
+        return await RNFS.exists(path);
+    }
+    async stat(path) {
+        return await RNFS.stat(path);
+    }
+    async readDir(path) {
+        return await RNFS.readDir(path);
+    }
+    async copyFile(source, destination) {
+        await RNFS.copyFile(source, destination);
+    }
+    async moveFile(source, destination) {
+        await RNFS.moveFile(source, destination);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+export declare class FileSystemWeb implements IFileSystem {
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<any>;
+    readDir(path: string): Promise<any[]>;
+    copyFile(source: string, destination: string): Promise<void>;
+    moveFile(source: string, destination: string): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+export class FileSystemWeb {
+    getDocumentDirectory() {
+        return '/virtual-fs';
+    }
+    async resolveLocalFileSystemURL(url) {
+        throw new Error('File system operations not supported on web');
+    }
+    async getFolderBasedOnUserId(userId) {
+        return `/virtual-fs/users/${userId}`;
+    }
+    async deleteUserFolder(userId) {
+        console.warn('deleteUserFolder not supported on web');
+    }
+    async createDirectory(path) {
+        console.warn('createDirectory not supported on web');
+    }
+    async readFile(path, encoding) {
+        throw new Error('readFile not supported on web');
+    }
+    async writeFile(path, content, encoding) {
+        throw new Error('writeFile not supported on web');
+    }
+    async deleteFile(path) {
+        console.warn('deleteFile not supported on web');
+    }
+    async exists(path) {
+        return false;
+    }
+    async stat(path) {
+        throw new Error('stat not supported on web');
+    }
+    async readDir(path) {
+        return [];
+    }
+    async copyFile(source, destination) {
+        throw new Error('copyFile not supported on web');
+    }
+    async moveFile(source, destination) {
+        throw new Error('moveFile not supported on web');
+    }
+}

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

@@ -1,6 +1,7 @@
 /**
- * LocalStorage class provides a wrapper around React Native AsyncStorage
- * with convenient methods for storing and retrieving data.
+ * LocalStorage class provides a wrapper around platform-specific storage
+ * - Web: Uses browser localStorage
+ * - iOS/Android/Windows: Uses AsyncStorage
  */
 export declare class LocalStorage {
     /**

package/dist/local-storage/localStorage.js

@@ -1,7 +1,12 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Platform } from 'react-native';
+import { StorageWeb } from './services/StorageWeb';
+import { StorageNative } from './services/StorageNative';
+// Select storage implementation based on platform
+const storageImpl = Platform.OS === 'web' ? new StorageWeb() : new StorageNative();
 /**
- * LocalStorage class provides a wrapper around React Native AsyncStorage
- * with convenient methods for storing and retrieving data.
+ * LocalStorage class provides a wrapper around platform-specific storage
+ * - Web: Uses browser localStorage
+ * - iOS/Android/Windows: Uses AsyncStorage
  */
 export class LocalStorage {
     /**
@@ -11,7 +16,7 @@ export class LocalStorage {
      */
     static async getItem(key) {
         try {
-            const value = await AsyncStorage.getItem(key);
+            const value = await storageImpl.getItem(key);
             return value ? JSON.parse(value) : null;
         }
         catch (error) {
@@ -27,7 +32,7 @@ export class LocalStorage {
     static async setItem(key, value) {
         try {
             const jsonValue = JSON.stringify(value);
-            await AsyncStorage.setItem(key, jsonValue);
+            await storageImpl.setItem(key, jsonValue);
         }
         catch (error) {
             console.error(`Error setting item with key "${key}":`, error);
@@ -40,7 +45,7 @@ export class LocalStorage {
      */
     static async removeItem(key) {
         try {
-            await AsyncStorage.removeItem(key);
+            await storageImpl.removeItem(key);
         }
         catch (error) {
             console.error(`Error removing item with key "${key}":`, error);
@@ -52,7 +57,7 @@ export class LocalStorage {
      */
     static async clear() {
         try {
-            await AsyncStorage.clear();
+            await storageImpl.clear();
         }
         catch (error) {
             console.error('Error clearing storage:', error);
@@ -65,7 +70,7 @@ export class LocalStorage {
      */
     static async getAllKeys() {
         try {
-            return await AsyncStorage.getAllKeys();
+            return await storageImpl.getAllKeys();
         }
         catch (error) {
             console.error('Error getting all keys:', error);
@@ -79,7 +84,7 @@ export class LocalStorage {
      */
     static async multiGet(keys) {
         try {
-            const results = await AsyncStorage.multiGet(keys);
+            const results = await storageImpl.multiGet(keys);
             return results.map(([key, value]) => [
                 key,
                 value ? JSON.parse(value) : null
@@ -100,7 +105,7 @@ export class LocalStorage {
                 key,
                 JSON.stringify(value)
             ]);
-            await AsyncStorage.multiSet(jsonPairs);
+            await storageImpl.multiSet(jsonPairs);
         }
         catch (error) {
             console.error('Error setting multiple items:', error);
@@ -113,7 +118,7 @@ export class LocalStorage {
      */
     static async multiRemove(keys) {
         try {
-            await AsyncStorage.multiRemove(keys);
+            await storageImpl.multiRemove(keys);
         }
         catch (error) {
             console.error('Error removing multiple items:', error);

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

@@ -0,0 +1,10 @@
+export declare class StorageNative {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    getAllKeys(): Promise<readonly string[]>;
+    multiGet(keys: string[]): Promise<readonly [string, string | null][]>;
+    multiSet(keyValuePairs: Array<[string, string]>): Promise<void>;
+    multiRemove(keys: string[]): Promise<void>;
+}