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

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0014
+R-0.000.0015

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

@@ -1,13 +1,13 @@
 import * as RNFS from '@dr.pogodin/react-native-fs';
-import { IFileEntry } from '../FileSystem.types';
-export declare class FileSystemNative {
+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?: RNFS.EncodingT): Promise<string>;
-    writeFile(path: string, content: string, encoding?: RNFS.EncodingT): 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>;

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

@@ -1,4 +1,5 @@
 import * as RNFS from '@dr.pogodin/react-native-fs';
+import { RNFileEntry } from '../RNFileEntry';
 export class FileSystemNative {
     getDocumentDirectory() {
         return RNFS.DocumentDirectoryPath;
@@ -14,13 +15,7 @@ export class FileSystemNative {
         }
         const stat = await RNFS.stat(normalizedPath);
         const fileName = stat.name || normalizedPath.split('/').pop() || 'unknown';
-        return {
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-            name: fileName,
-            fullPath: stat.path,
-            nativeURL: `file://${stat.path}`,
-        };
+        return new RNFileEntry(stat.isFile(), stat.isDirectory(), fileName, stat.path, `file://${stat.path}`);
     }
     async getFolderBasedOnUserId(userId) {
         const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;

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

@@ -1,12 +1,12 @@
-import { IFileEntry } from '../FileSystem.types';
-export declare class FileSystemWeb {
+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?: string): Promise<string>;
-    writeFile(path: string, content: string, encoding?: 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

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

@@ -1,61 +0,0 @@
-import { IFileEntry } from './FileSystem.types';
-/**
- * Base File System Class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
- * - Web: Limited functionality (not supported)
- */
-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?: string): Promise<string>;
-    /**
-     * Write file content
-     */
-    static writeFile(path: string, content: string, encoding?: string): 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>;
-}

package/dist/file-system/BaseFileSystem.js

@@ -1,164 +0,0 @@
-// BaseFileSystem.ts
-// Base file system implementation
-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();
-/**
- * Base File System Class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
- * - Web: Limited functionality (not supported)
- */
-export class BaseFileSystem {
-    /**
-     * 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;
-        }
-    }
-}