@idealyst/storage 1.0.50

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@idealyst/storage",
+  "version": "1.0.50",
+  "description": "Cross-platform storage abstraction for React and React Native",
+  "documentation": "https://github.com/your-username/idealyst-framework/tree/main/packages/storage#readme",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "react-native": "src/index.native.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/idealyst-framework.git",
+    "directory": "packages/storage"
+  },
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "react-native": "./src/index.native.ts",
+      "browser": "./src/index.web.ts",
+      "import": "./src/index.ts",
+      "require": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "echo 'Publishing TypeScript source directly'",
+    "publish:npm": "npm publish"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.0.0",
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "react",
+    "react-native",
+    "storage",
+    "cross-platform",
+    "localStorage",
+    "AsyncStorage"
+  ]
+}

package/src/async-storage.d.ts

@@ -0,0 +1,15 @@
+declare module '@react-native-async-storage/async-storage' {
+  export interface AsyncStorageStatic {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    multiGet(keys: string[]): Promise<Array<[string, string | null]>>;
+    multiSet(keyValuePairs: Array<[string, string]>): Promise<void>;
+    multiRemove(keys: string[]): Promise<void>;
+  }
+
+  const AsyncStorage: AsyncStorageStatic;
+  export default AsyncStorage;
+}

package/src/index.native.ts

@@ -0,0 +1,8 @@
+import BaseStorage from './storage';
+import NativeStorage from './storage.native';
+
+const Storage = new BaseStorage(new NativeStorage());
+
+export default Storage;
+export { BaseStorage, NativeStorage };
+export * from './types';

package/src/index.ts

@@ -0,0 +1,2 @@
+export { default as Storage } from './storage';
+export * from './types';

package/src/index.web.ts

@@ -0,0 +1,8 @@
+import BaseStorage from './storage';
+import WebStorage from './storage.web';
+
+const Storage = new BaseStorage(new WebStorage());
+
+export default Storage;
+export { BaseStorage, WebStorage };
+export * from './types';

package/src/storage.native.ts

@@ -0,0 +1,79 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { IStorage } from './types';
+
+class NativeStorage implements IStorage {
+  async getItem(key: string): Promise<string | null> {
+    try {
+      return await AsyncStorage.getItem(key);
+    } catch (error) {
+      console.error('Error getting item from AsyncStorage:', error);
+      return null;
+    }
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(key, value);
+    } catch (error) {
+      console.error('Error setting item in AsyncStorage:', error);
+      throw error;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(key);
+    } catch (error) {
+      console.error('Error removing item from AsyncStorage:', error);
+      throw error;
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      await AsyncStorage.clear();
+    } catch (error) {
+      console.error('Error clearing AsyncStorage:', error);
+      throw error;
+    }
+  }
+
+  async getAllKeys(): Promise<string[]> {
+    try {
+      return await AsyncStorage.getAllKeys();
+    } catch (error) {
+      console.error('Error getting all keys from AsyncStorage:', error);
+      return [];
+    }
+  }
+
+  async multiGet(keys: string[]): Promise<Array<[string, string | null]>> {
+    try {
+      const results = await AsyncStorage.multiGet(keys);
+      return results as Array<[string, string | null]>;
+    } catch (error) {
+      console.error('Error in multiGet from AsyncStorage:', error);
+      return keys.map(key => [key, null]);
+    }
+  }
+
+  async multiSet(keyValuePairs: Array<[string, string]>): Promise<void> {
+    try {
+      await AsyncStorage.multiSet(keyValuePairs);
+    } catch (error) {
+      console.error('Error in multiSet to AsyncStorage:', error);
+      throw error;
+    }
+  }
+
+  async multiRemove(keys: string[]): Promise<void> {
+    try {
+      await AsyncStorage.multiRemove(keys);
+    } catch (error) {
+      console.error('Error in multiRemove from AsyncStorage:', error);
+      throw error;
+    }
+  }
+}
+
+export default NativeStorage;

package/src/storage.ts

@@ -0,0 +1,82 @@
+import { IStorage, IStorageWithListener, StorageListener } from './types';
+
+class BaseStorage implements IStorageWithListener {
+  protected storage: IStorage;
+  protected listeners: Set<StorageListener> = new Set();
+
+  constructor(storage: IStorage) {
+    this.storage = storage;
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    return this.storage.getItem(key);
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    await this.storage.setItem(key, value);
+    this.notifyListeners(key, value);
+  }
+
+  async removeItem(key: string): Promise<void> {
+    await this.storage.removeItem(key);
+    this.notifyListeners(key, null);
+  }
+
+  async clear(): Promise<void> {
+    await this.storage.clear();
+    this.notifyListeners(null, null);
+  }
+
+  async getAllKeys(): Promise<string[]> {
+    return this.storage.getAllKeys();
+  }
+
+  async multiGet(keys: string[]): Promise<Array<[string, string | null]>> {
+    if (this.storage.multiGet) {
+      return this.storage.multiGet(keys);
+    }
+    
+    const results = await Promise.all(
+      keys.map(async (key) => {
+        const value = await this.getItem(key);
+        return [key, value] as [string, string | null];
+      })
+    );
+    return results;
+  }
+
+  async multiSet(keyValuePairs: Array<[string, string]>): Promise<void> {
+    if (this.storage.multiSet) {
+      await this.storage.multiSet(keyValuePairs);
+      keyValuePairs.forEach(([key, value]) => this.notifyListeners(key, value));
+      return;
+    }
+    
+    await Promise.all(
+      keyValuePairs.map(([key, value]) => this.setItem(key, value))
+    );
+  }
+
+  async multiRemove(keys: string[]): Promise<void> {
+    if (this.storage.multiRemove) {
+      await this.storage.multiRemove(keys);
+      keys.forEach((key) => this.notifyListeners(key, null));
+      return;
+    }
+    
+    await Promise.all(keys.map((key) => this.removeItem(key)));
+  }
+
+  addListener(listener: StorageListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  protected notifyListeners(key: string | null, value: string | null): void {
+    this.listeners.forEach((listener) => listener(key, value));
+  }
+}
+
+export default BaseStorage;

package/src/storage.web.ts

@@ -0,0 +1,84 @@
+import { IStorage } from './types';
+
+class WebStorage implements IStorage {
+  private storage: Storage;
+
+  constructor(storage: Storage = window.localStorage) {
+    this.storage = storage;
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    try {
+      return this.storage.getItem(key);
+    } catch (error) {
+      console.error('Error getting item from storage:', error);
+      return null;
+    }
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    try {
+      this.storage.setItem(key, value);
+    } catch (error) {
+      console.error('Error setting item in storage:', error);
+      throw error;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    try {
+      this.storage.removeItem(key);
+    } catch (error) {
+      console.error('Error removing item from storage:', error);
+      throw error;
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      this.storage.clear();
+    } catch (error) {
+      console.error('Error clearing storage:', error);
+      throw error;
+    }
+  }
+
+  async getAllKeys(): Promise<string[]> {
+    try {
+      const keys: string[] = [];
+      for (let i = 0; i < this.storage.length; i++) {
+        const key = this.storage.key(i);
+        if (key !== null) {
+          keys.push(key);
+        }
+      }
+      return keys;
+    } catch (error) {
+      console.error('Error getting all keys from storage:', error);
+      return [];
+    }
+  }
+
+  async multiGet(keys: string[]): Promise<Array<[string, string | null]>> {
+    return Promise.all(
+      keys.map(async (key) => {
+        const value = await this.getItem(key);
+        return [key, value] as [string, string | null];
+      })
+    );
+  }
+
+  async multiSet(keyValuePairs: Array<[string, string]>): Promise<void> {
+    for (const [key, value] of keyValuePairs) {
+      await this.setItem(key, value);
+    }
+  }
+
+  async multiRemove(keys: string[]): Promise<void> {
+    for (const key of keys) {
+      await this.removeItem(key);
+    }
+  }
+}
+
+export default WebStorage;

package/src/types.ts

@@ -0,0 +1,16 @@
+export interface IStorage {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  clear: () => Promise<void>;
+  getAllKeys: () => Promise<string[]>;
+  multiGet?: (keys: string[]) => Promise<Array<[string, string | null]>>;
+  multiSet?: (keyValuePairs: Array<[string, string]>) => Promise<void>;
+  multiRemove?: (keys: string[]) => Promise<void>;
+}
+
+export type StorageListener = (key: string | null, value: string | null) => void;
+
+export interface IStorageWithListener extends IStorage {
+  addListener: (listener: StorageListener) => () => void;
+}