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

package/dist/device-info/BaseDeviceInfo.d.ts

@@ -0,0 +1,39 @@
+import { IDeviceInfo } from './DeviceInfo.types';
+/**
+ * Base Device Information Class
+ * Handles device information retrieval for React Native
+ */
+export declare class BaseDeviceInfo {
+    private static cachedDeviceInfo;
+    /**
+     * Get comprehensive device information (async)
+     * Call this once during app initialization to populate cache
+     */
+    static getDeviceInfo(): Promise<IDeviceInfo>;
+    /**
+     * Get device information synchronously (returns cached data)
+     * Returns loading state if not yet initialized
+     * Call getDeviceInfo() first to populate cache
+     */
+    static getDeviceInfoSync(): IDeviceInfo;
+    /**
+     * Get platform name
+     */
+    static getPlatform(): string;
+    /**
+     * Get frontend type
+     */
+    static getFrontendType(): string;
+    /**
+     * Check if device is a tablet
+     */
+    static isTablet(): Promise<boolean>;
+    /**
+     * Get app version
+     */
+    static getAppVersion(): Promise<string>;
+    /**
+     * Get build number
+     */
+    static getBuildNumber(): Promise<string>;
+}

package/dist/device-info/BaseDeviceInfo.js

@@ -0,0 +1,116 @@
+// BaseDeviceInfo.ts
+// Base device information implementation
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+/**
+ * Base Device Information Class
+ * Handles device information retrieval for React Native
+ */
+export class BaseDeviceInfo {
+    /**
+     * Get comprehensive device information (async)
+     * Call this once during app initialization to populate cache
+     */
+    static async getDeviceInfo() {
+        if (this.cachedDeviceInfo) {
+            return this.cachedDeviceInfo;
+        }
+        try {
+            const deviceInfo = {
+                platform: Platform.OS,
+                model: await DeviceInfo.getModel(),
+                version: Platform.Version.toString(),
+                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+                manufacturer: await DeviceInfo.getManufacturer(),
+                uuid: await DeviceInfo.getUniqueId(),
+            };
+            this.cachedDeviceInfo = deviceInfo;
+            return deviceInfo;
+        }
+        catch (error) {
+            console.error('Error getting device info:', error);
+            const fallback = {
+                platform: Platform.OS,
+                model: 'Unknown',
+                version: Platform.Version.toString(),
+                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+            };
+            this.cachedDeviceInfo = fallback;
+            return fallback;
+        }
+    }
+    /**
+     * Get device information synchronously (returns cached data)
+     * Returns loading state if not yet initialized
+     * Call getDeviceInfo() first to populate cache
+     */
+    static getDeviceInfoSync() {
+        if (this.cachedDeviceInfo) {
+            return this.cachedDeviceInfo;
+        }
+        // Return immediate fallback while async initialization happens
+        return {
+            platform: Platform.OS,
+            model: 'Loading...',
+            version: Platform.Version.toString(),
+            isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+        };
+    }
+    /**
+     * Get platform name
+     */
+    static getPlatform() {
+        return Platform.OS;
+    }
+    /**
+     * Get frontend type
+     */
+    static getFrontendType() {
+        if (Platform.OS === 'ios') {
+            return 'APPLE_PHONE';
+        }
+        else if (Platform.OS === 'android') {
+            return 'ANDROID_PHONE';
+        }
+        else if (Platform.OS === 'windows') {
+            return 'WINDOWS_PHONE';
+        }
+        else {
+            return 'UNKNOWN';
+        }
+    }
+    /**
+     * Check if device is a tablet
+     */
+    static async isTablet() {
+        try {
+            return await DeviceInfo.isTablet();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get app version
+     */
+    static async getAppVersion() {
+        try {
+            return await DeviceInfo.getVersion();
+        }
+        catch (error) {
+            return '1.0.0';
+        }
+    }
+    /**
+     * Get build number
+     */
+    static async getBuildNumber() {
+        try {
+            return await DeviceInfo.getBuildNumber();
+        }
+        catch (error) {
+            return '1';
+        }
+    }
+}
+BaseDeviceInfo.cachedDeviceInfo = null;

package/dist/device-info/DeviceInfo.d.ts

@@ -0,0 +1,9 @@
+import { BaseDeviceInfo } from './BaseDeviceInfo';
+/**
+ * DeviceInfo class
+ * Extends BaseDeviceInfo
+ */
+export declare class DeviceInfo extends BaseDeviceInfo {
+}
+export type { IDeviceInfo } from './DeviceInfo.types';
+export default DeviceInfo;

package/dist/device-info/DeviceInfo.js

@@ -0,0 +1,11 @@
+// DeviceInfo.ts
+// Main device info export
+import { BaseDeviceInfo } from './BaseDeviceInfo';
+/**
+ * DeviceInfo class
+ * Extends BaseDeviceInfo
+ */
+export class DeviceInfo extends BaseDeviceInfo {
+}
+// Default export
+export default DeviceInfo;

package/dist/device-info/DeviceInfo.types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Device information interface
+ */
+export interface IDeviceInfo {
+    platform: string;
+    model: string;
+    version: string;
+    isMobile: boolean;
+    manufacturer?: string;
+    uuid?: string;
+}

package/dist/device-info/DeviceInfo.types.js

@@ -0,0 +1,3 @@
+// DeviceInfo.types.ts
+// Type definitions for device info module
+export {};

package/dist/device-info/index.d.ts

@@ -0,0 +1,3 @@
+export { DeviceInfo } from './DeviceInfo';
+export type { IDeviceInfo } from './DeviceInfo.types';
+export { default } from './DeviceInfo';

package/dist/device-info/index.js

@@ -0,0 +1,3 @@
+// Device Info module exports
+export { DeviceInfo } from './DeviceInfo';
+export { default } from './DeviceInfo';

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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,164 @@
+// 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;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { BaseFileSystem } from './BaseFileSystem';
+/**
+ * FileSystem class
+ * Extends BaseFileSystem
+ */
+export declare class FileSystem extends BaseFileSystem {
+}
+export type { IFileEntry } from './FileSystem.types';
+export default FileSystem;

package/dist/file-system/FileSystem.js

@@ -0,0 +1,11 @@
+// FileSystem.ts
+// Main file system export
+import { BaseFileSystem } from './BaseFileSystem';
+/**
+ * FileSystem class
+ * Extends BaseFileSystem
+ */
+export class FileSystem extends BaseFileSystem {
+}
+// Default export
+export default FileSystem;

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

@@ -0,0 +1,11 @@
+/**
+ * File entry interface
+ */
+export interface IFileEntry {
+    isFile: boolean;
+    isDirectory: boolean;
+    name: string;
+    fullPath: string;
+    filesystem?: any;
+    nativeURL?: string;
+}

package/dist/file-system/FileSystem.types.js

@@ -0,0 +1,3 @@
+// FileSystem.types.ts
+// Type definitions for file system module
+export {};

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

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

package/dist/file-system/index.js

@@ -0,0 +1,3 @@
+// File System module exports
+export { FileSystem } from './FileSystem';
+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 } from '../FileSystem.types';
+export declare class FileSystemNative {
+    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>;
+    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,73 @@
+import * as RNFS from '@dr.pogodin/react-native-fs';
+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 {
+            isFile: stat.isFile(),
+            isDirectory: stat.isDirectory(),
+            name: fileName,
+            fullPath: stat.path,
+            nativeURL: `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 } from '../FileSystem.types';
+export declare class FileSystemWeb {
+    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>;
+    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/index.d.ts

@@ -0,0 +1 @@
+export { LocalStorage } from './localStorage';

package/dist/local-storage/index.js

@@ -0,0 +1,2 @@
+// Local Storage module exports
+export { LocalStorage } from './localStorage';