@umituz/react-native-auth 1.12.0 → 2.0.1

package/lib/__tests__/utils/AuthValidation.test.js

@@ -0,0 +1,222 @@
+/**
+ * AuthValidation Tests
+ */
+import { validateEmail, validatePasswordForLogin, validatePasswordForRegister, validatePasswordConfirmation, validateDisplayName, } from '../../../src/infrastructure/utils/AuthValidation';
+import { DEFAULT_PASSWORD_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
+import { initializeAuthPackage } from '../../../src/infrastructure/services/AuthPackage';
+describe('AuthValidation', () => {
+    beforeEach(() => {
+        // Reset package config before each test
+        initializeAuthPackage();
+    });
+    describe('validateEmail', () => {
+        it('should reject empty email', () => {
+            const result = validateEmail('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email is required');
+        });
+        it('should reject whitespace-only email', () => {
+            const result = validateEmail('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email is required');
+        });
+        it('should reject invalid email format', () => {
+            const result = validateEmail('invalid-email');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Please enter a valid email address');
+        });
+        it('should accept valid email format', () => {
+            const result = validateEmail('test@example.com');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept valid email with subdomain', () => {
+            const result = validateEmail('test@mail.example.com');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should trim whitespace', () => {
+            const result = validateEmail('  test@example.com  ');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+    });
+    describe('validatePasswordForLogin', () => {
+        it('should reject empty password', () => {
+            const result = validatePasswordForLogin('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password is required');
+        });
+        it('should accept any non-empty password', () => {
+            const result = validatePasswordForLogin('any');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept password with spaces', () => {
+            const result = validatePasswordForLogin('  password  ');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+    });
+    describe('validatePasswordForRegister', () => {
+        const config = DEFAULT_PASSWORD_CONFIG;
+        it('should reject empty password', () => {
+            const result = validatePasswordForRegister('', config);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password is required');
+            expect(result.requirements.hasMinLength).toBe(false);
+        });
+        it('should reject password that is too short', () => {
+            const result = validatePasswordForRegister('123', config);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe(`Password must be at least ${config.minLength} characters`);
+            expect(result.requirements.hasMinLength).toBe(false);
+        });
+        it('should accept password that meets minimum length', () => {
+            const result = validatePasswordForRegister('12345678', config);
+            expect(result.requirements.hasMinLength).toBe(true);
+        });
+        it('should validate uppercase requirement', () => {
+            const configWithUppercase = {
+                ...config,
+                requireUppercase: true,
+            };
+            const result = validatePasswordForRegister('password', configWithUppercase);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password must contain at least one uppercase letter');
+            expect(result.requirements.hasUppercase).toBe(false);
+            const validResult = validatePasswordForRegister('Password', configWithUppercase);
+            expect(validResult.requirements.hasUppercase).toBe(true);
+        });
+        it('should validate lowercase requirement', () => {
+            const configWithLowercase = {
+                ...config,
+                requireLowercase: true,
+            };
+            const result = validatePasswordForRegister('PASSWORD', configWithLowercase);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password must contain at least one lowercase letter');
+            expect(result.requirements.hasLowercase).toBe(false);
+            const validResult = validatePasswordForRegister('Password', configWithLowercase);
+            expect(validResult.requirements.hasLowercase).toBe(true);
+        });
+        it('should validate number requirement', () => {
+            const configWithNumber = {
+                ...config,
+                requireNumber: true,
+            };
+            const result = validatePasswordForRegister('Password', configWithNumber);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password must contain at least one number');
+            expect(result.requirements.hasNumber).toBe(false);
+            const validResult = validatePasswordForRegister('Password1', configWithNumber);
+            expect(validResult.requirements.hasNumber).toBe(true);
+        });
+        it('should validate special character requirement', () => {
+            const configWithSpecial = {
+                ...config,
+                requireSpecialChar: true,
+            };
+            const result = validatePasswordForRegister('Password1', configWithSpecial);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Password must contain at least one special character');
+            expect(result.requirements.hasSpecialChar).toBe(false);
+            const validResult = validatePasswordForRegister('Password1!', configWithSpecial);
+            expect(validResult.requirements.hasSpecialChar).toBe(true);
+        });
+        it('should accept password that meets all requirements', () => {
+            const strictConfig = {
+                ...config,
+                requireUppercase: true,
+                requireLowercase: true,
+                requireNumber: true,
+                requireSpecialChar: true,
+            };
+            const result = validatePasswordForRegister('Password1!', strictConfig);
+            expect(result.isValid).toBe(true);
+            expect(result.requirements).toEqual({
+                hasMinLength: true,
+                hasUppercase: true,
+                hasLowercase: true,
+                hasNumber: true,
+                hasSpecialChar: true,
+            });
+        });
+        it('should skip requirements when disabled', () => {
+            const lenientConfig = {
+                ...config,
+                requireUppercase: false,
+                requireLowercase: false,
+                requireNumber: false,
+                requireSpecialChar: false,
+            };
+            const result = validatePasswordForRegister('password', lenientConfig);
+            expect(result.requirements).toEqual({
+                hasMinLength: true,
+                hasUppercase: true, // Should be true when requirement is disabled
+                hasLowercase: true, // Should be true when requirement is disabled
+                hasNumber: true, // Should be true when requirement is disabled
+                hasSpecialChar: true, // Should be true when requirement is disabled
+            });
+        });
+    });
+    describe('validatePasswordConfirmation', () => {
+        it('should reject empty confirmation', () => {
+            const result = validatePasswordConfirmation('password', '');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Please confirm your password');
+        });
+        it('should reject mismatched passwords', () => {
+            const result = validatePasswordConfirmation('password', 'different');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Passwords do not match');
+        });
+        it('should accept matching passwords', () => {
+            const result = validatePasswordConfirmation('password', 'password');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should handle empty passwords that match', () => {
+            const result = validatePasswordConfirmation('', '');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+    });
+    describe('validateDisplayName', () => {
+        it('should reject empty name', () => {
+            const result = validateDisplayName('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Name is required');
+        });
+        it('should reject whitespace-only name', () => {
+            const result = validateDisplayName('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Name is required');
+        });
+        it('should reject name that is too short', () => {
+            const result = validateDisplayName('A');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Name must be at least 2 characters');
+        });
+        it('should accept name that meets minimum length', () => {
+            const result = validateDisplayName('Al');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should use custom minimum length', () => {
+            const result = validateDisplayName('Al', 3);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Name must be at least 3 characters');
+        });
+        it('should trim whitespace', () => {
+            const result = validateDisplayName('  John Doe  ');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept name with special characters', () => {
+            const result = validateDisplayName('John-O\'Connor');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+    });
+});

package/lib/application/ports/IAuthProvider.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Auth Provider Interface
+ * Port for provider-agnostic authentication (Firebase, Supabase, etc.)
+ */
+import type { AuthUser } from "../../domain/entities/AuthUser";
+export interface AuthCredentials {
+    email: string;
+    password: string;
+}
+export interface SignUpCredentials extends AuthCredentials {
+    displayName?: string;
+}
+export interface IAuthProvider {
+    /**
+     * Initialize the auth provider
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if provider is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Sign in with email and password
+     */
+    signIn(credentials: AuthCredentials): Promise<AuthUser>;
+    /**
+     * Sign up with email, password, and optional display name
+     */
+    signUp(credentials: SignUpCredentials): Promise<AuthUser>;
+    /**
+     * Sign out current user
+     */
+    signOut(): Promise<void>;
+    /**
+     * Get current authenticated user
+     */
+    getCurrentUser(): AuthUser | null;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
+}

package/lib/application/ports/IAuthProvider.js

@@ -0,0 +1,5 @@
+/**
+ * Auth Provider Interface
+ * Port for provider-agnostic authentication (Firebase, Supabase, etc.)
+ */
+export {};

package/lib/application/ports/IAuthService.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Auth Service Interface
+ * Port for authentication operations (provider-agnostic)
+ */
+import type { AuthUser } from "../../domain/entities/AuthUser";
+export interface SignUpParams {
+    email: string;
+    password: string;
+    displayName?: string;
+}
+export interface SignInParams {
+    email: string;
+    password: string;
+}
+export interface IAuthService {
+    /**
+     * Sign up a new user
+     */
+    signUp(params: SignUpParams): Promise<AuthUser>;
+    /**
+     * Sign in an existing user
+     */
+    signIn(params: SignInParams): Promise<AuthUser>;
+    /**
+     * Sign out current user
+     */
+    signOut(): Promise<void>;
+    /**
+     * Set guest mode (no authentication)
+     */
+    setGuestMode(): Promise<void>;
+    /**
+     * Check if currently in guest mode
+     */
+    getIsGuestMode(): boolean;
+    /**
+     * Get current authenticated user
+     */
+    getCurrentUser(): AuthUser | null;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
+    /**
+     * Check if auth is initialized
+     */
+    isInitialized(): boolean;
+}

package/lib/application/ports/IAuthService.js

@@ -0,0 +1,5 @@
+/**
+ * Auth Service Interface
+ * Port for authentication operations (provider-agnostic)
+ */
+export {};

package/lib/domain/entities/AuthUser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Auth User Entity
+ * Provider-agnostic user representation
+ */
+export interface AuthUser {
+    uid: string;
+    email: string | null;
+    displayName: string | null;
+    isAnonymous: boolean;
+    emailVerified: boolean;
+    photoURL: string | null;
+}

package/lib/domain/entities/AuthUser.js

@@ -0,0 +1,5 @@
+/**
+ * Auth User Entity
+ * Provider-agnostic user representation
+ */
+export {};

package/lib/domain/errors/AuthError.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Auth Error Types
+ * Domain-specific error classes for authentication operations
+ */
+export declare class AuthError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class AuthInitializationError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthConfigurationError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthValidationError extends AuthError {
+    field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class AuthNetworkError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthUserNotFoundError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthWrongPasswordError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthEmailAlreadyInUseError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthWeakPasswordError extends AuthError {
+    constructor(message?: string);
+}
+export declare class AuthInvalidEmailError extends AuthError {
+    constructor(message?: string);
+}

package/lib/domain/errors/AuthError.js

@@ -0,0 +1,76 @@
+/**
+ * Auth Error Types
+ * Domain-specific error classes for authentication operations
+ */
+export class AuthError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "AuthError";
+        Object.setPrototypeOf(this, AuthError.prototype);
+    }
+}
+export class AuthInitializationError extends AuthError {
+    constructor(message = "Firebase Auth is not initialized") {
+        super(message, "AUTH_NOT_INITIALIZED");
+        this.name = "AuthInitializationError";
+        Object.setPrototypeOf(this, AuthInitializationError.prototype);
+    }
+}
+export class AuthConfigurationError extends AuthError {
+    constructor(message = "Invalid auth configuration") {
+        super(message, "AUTH_CONFIG_ERROR");
+        this.name = "AuthConfigurationError";
+        Object.setPrototypeOf(this, AuthConfigurationError.prototype);
+    }
+}
+export class AuthValidationError extends AuthError {
+    constructor(message, field) {
+        super(message, "AUTH_VALIDATION_ERROR");
+        this.field = field;
+        this.name = "AuthValidationError";
+        Object.setPrototypeOf(this, AuthValidationError.prototype);
+    }
+}
+export class AuthNetworkError extends AuthError {
+    constructor(message = "Network error during authentication") {
+        super(message, "AUTH_NETWORK_ERROR");
+        this.name = "AuthNetworkError";
+        Object.setPrototypeOf(this, AuthNetworkError.prototype);
+    }
+}
+export class AuthUserNotFoundError extends AuthError {
+    constructor(message = "User not found") {
+        super(message, "AUTH_USER_NOT_FOUND");
+        this.name = "AuthUserNotFoundError";
+        Object.setPrototypeOf(this, AuthUserNotFoundError.prototype);
+    }
+}
+export class AuthWrongPasswordError extends AuthError {
+    constructor(message = "Wrong password") {
+        super(message, "AUTH_WRONG_PASSWORD");
+        this.name = "AuthWrongPasswordError";
+        Object.setPrototypeOf(this, AuthWrongPasswordError.prototype);
+    }
+}
+export class AuthEmailAlreadyInUseError extends AuthError {
+    constructor(message = "Email already in use") {
+        super(message, "AUTH_EMAIL_ALREADY_IN_USE");
+        this.name = "AuthEmailAlreadyInUseError";
+        Object.setPrototypeOf(this, AuthEmailAlreadyInUseError.prototype);
+    }
+}
+export class AuthWeakPasswordError extends AuthError {
+    constructor(message = "Password is too weak") {
+        super(message, "AUTH_WEAK_PASSWORD");
+        this.name = "AuthWeakPasswordError";
+        Object.setPrototypeOf(this, AuthWeakPasswordError.prototype);
+    }
+}
+export class AuthInvalidEmailError extends AuthError {
+    constructor(message = "Invalid email address") {
+        super(message, "AUTH_INVALID_EMAIL");
+        this.name = "AuthInvalidEmailError";
+        Object.setPrototypeOf(this, AuthInvalidEmailError.prototype);
+    }
+}

package/lib/domain/value-objects/AuthConfig.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Auth Configuration Value Object
+ * Validates and stores authentication configuration
+ */
+export interface PasswordConfig {
+    minLength: number;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireNumber: boolean;
+    requireSpecialChar: boolean;
+}
+export interface AuthConfig {
+    password: PasswordConfig;
+}
+export declare const DEFAULT_PASSWORD_CONFIG: PasswordConfig;
+export declare const DEFAULT_AUTH_CONFIG: AuthConfig;

package/lib/domain/value-objects/AuthConfig.js

@@ -0,0 +1,14 @@
+/**
+ * Auth Configuration Value Object
+ * Validates and stores authentication configuration
+ */
+export const DEFAULT_PASSWORD_CONFIG = {
+    minLength: 6,
+    requireUppercase: false,
+    requireLowercase: false,
+    requireNumber: false,
+    requireSpecialChar: false,
+};
+export const DEFAULT_AUTH_CONFIG = {
+    password: DEFAULT_PASSWORD_CONFIG,
+};

package/lib/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * React Native Auth - Public API
+ *
+ * Domain-Driven Design (DDD) Architecture
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all Auth operations.
+ * ALL imports from the Auth package MUST go through this file.
+ *
+ * Architecture:
+ * - domain: Entities, value objects, errors (business logic)
+ * - application: Ports (interfaces)
+ * - infrastructure: Auth providers and service implementation
+ * - presentation: Hooks (React integration)
+ *
+ * Usage:
+ *   import { initializeAuthService, useAuth } from '@umituz/react-native-auth';
+ */
+export type { AuthUser } from './domain/entities/AuthUser';
+export { AuthError, AuthInitializationError, AuthConfigurationError, AuthValidationError, AuthNetworkError, AuthUserNotFoundError, AuthWrongPasswordError, AuthEmailAlreadyInUseError, AuthWeakPasswordError, AuthInvalidEmailError, } from './domain/errors/AuthError';
+export type { AuthConfig, PasswordConfig } from './domain/value-objects/AuthConfig';
+export { DEFAULT_AUTH_CONFIG, DEFAULT_PASSWORD_CONFIG } from './domain/value-objects/AuthConfig';
+export type { IAuthService, SignUpParams, SignInParams } from './application/ports/IAuthService';
+export type { IAuthProvider, AuthCredentials, SignUpCredentials, } from './application/ports/IAuthProvider';
+export { FirebaseAuthProvider } from './infrastructure/providers/FirebaseAuthProvider';
+export { AuthService, initializeAuthService, getAuthService, resetAuthService, } from './infrastructure/services/AuthService';
+export { validateEmail, validatePasswordForLogin, validatePasswordForRegister, validatePasswordConfirmation, validateDisplayName, } from './infrastructure/utils/AuthValidation';
+export type { ValidationResult, PasswordStrengthResult, PasswordRequirements, } from './infrastructure/utils/AuthValidation';
+export { useAuth } from './presentation/hooks/useAuth';
+export type { UseAuthResult } from './presentation/hooks/useAuth';
+export { LoginScreen } from './presentation/screens/LoginScreen';
+export { RegisterScreen } from './presentation/screens/RegisterScreen';
+export { AuthNavigator } from './presentation/navigation/AuthNavigator';
+export type { AuthStackParamList, AuthNavigatorProps, } from './presentation/navigation/AuthNavigator';
+export { AuthContainer } from './presentation/components/AuthContainer';
+export { AuthHeader } from './presentation/components/AuthHeader';
+export { AuthFormCard } from './presentation/components/AuthFormCard';
+export { LoginForm } from './presentation/components/LoginForm';
+export { RegisterForm } from './presentation/components/RegisterForm';
+export { AuthLegalLinks } from './presentation/components/AuthLegalLinks';
+export type { AuthLegalLinksProps } from './presentation/components/AuthLegalLinks';
+export { PasswordStrengthIndicator } from './presentation/components/PasswordStrengthIndicator';
+export type { PasswordStrengthIndicatorProps } from './presentation/components/PasswordStrengthIndicator';
+export { PasswordMatchIndicator } from './presentation/components/PasswordMatchIndicator';
+export type { PasswordMatchIndicatorProps } from './presentation/components/PasswordMatchIndicator';
+export { getAuthErrorLocalizationKey } from './presentation/utils/getAuthErrorMessage';

package/lib/index.js

@@ -0,0 +1,59 @@
+/**
+ * React Native Auth - Public API
+ *
+ * Domain-Driven Design (DDD) Architecture
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all Auth operations.
+ * ALL imports from the Auth package MUST go through this file.
+ *
+ * Architecture:
+ * - domain: Entities, value objects, errors (business logic)
+ * - application: Ports (interfaces)
+ * - infrastructure: Auth providers and service implementation
+ * - presentation: Hooks (React integration)
+ *
+ * Usage:
+ *   import { initializeAuthService, useAuth } from '@umituz/react-native-auth';
+ */
+// =============================================================================
+// DOMAIN LAYER - Errors
+// =============================================================================
+export { AuthError, AuthInitializationError, AuthConfigurationError, AuthValidationError, AuthNetworkError, AuthUserNotFoundError, AuthWrongPasswordError, AuthEmailAlreadyInUseError, AuthWeakPasswordError, AuthInvalidEmailError, } from './domain/errors/AuthError';
+export { DEFAULT_AUTH_CONFIG, DEFAULT_PASSWORD_CONFIG } from './domain/value-objects/AuthConfig';
+// =============================================================================
+// INFRASTRUCTURE LAYER - Providers
+// =============================================================================
+export { FirebaseAuthProvider } from './infrastructure/providers/FirebaseAuthProvider';
+// =============================================================================
+// INFRASTRUCTURE LAYER - Services
+// =============================================================================
+export { AuthService, initializeAuthService, getAuthService, resetAuthService, } from './infrastructure/services/AuthService';
+// =============================================================================
+// INFRASTRUCTURE LAYER - Validation
+// =============================================================================
+export { validateEmail, validatePasswordForLogin, validatePasswordForRegister, validatePasswordConfirmation, validateDisplayName, } from './infrastructure/utils/AuthValidation';
+// =============================================================================
+// PRESENTATION LAYER - Hooks
+// =============================================================================
+export { useAuth } from './presentation/hooks/useAuth';
+// =============================================================================
+// PRESENTATION LAYER - Screens & Navigation
+// =============================================================================
+export { LoginScreen } from './presentation/screens/LoginScreen';
+export { RegisterScreen } from './presentation/screens/RegisterScreen';
+export { AuthNavigator } from './presentation/navigation/AuthNavigator';
+// =============================================================================
+// PRESENTATION LAYER - Components
+// =============================================================================
+export { AuthContainer } from './presentation/components/AuthContainer';
+export { AuthHeader } from './presentation/components/AuthHeader';
+export { AuthFormCard } from './presentation/components/AuthFormCard';
+export { LoginForm } from './presentation/components/LoginForm';
+export { RegisterForm } from './presentation/components/RegisterForm';
+export { AuthLegalLinks } from './presentation/components/AuthLegalLinks';
+export { PasswordStrengthIndicator } from './presentation/components/PasswordStrengthIndicator';
+export { PasswordMatchIndicator } from './presentation/components/PasswordMatchIndicator';
+// =============================================================================
+// PRESENTATION LAYER - Utilities
+// =============================================================================
+export { getAuthErrorLocalizationKey } from './presentation/utils/getAuthErrorMessage';

package/lib/infrastructure/adapters/StorageProviderAdapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Storage Provider Adapter
+ * Adapts external storage implementations to our IStorageProvider interface
+ */
+import type { IStorageProvider } from "../services/GuestModeService";
+export declare class StorageProviderAdapter implements IStorageProvider {
+    private storage;
+    constructor(storage: any);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+/**
+ * Create storage provider from various storage implementations
+ */
+export declare function createStorageProvider(storage: any): IStorageProvider;