react-wire-persisted 2.0.1 → 3.0.0

package/src/providers/LocalStorageProvider.js

@@ -1,194 +0,0 @@
-import StorageProvider from './StorageProvider'
-import { fakeLocalStorage, isPrimitive, isLocalStorageAvailable } from '../utils'
-
-/**
- * A storage provider for `localStorage`
- * @see `StorageProvider.js` for documentation
- */
-class LocalStorageProvider extends StorageProvider {
-    
-    constructor(namespace = null, registry = {}) {
-
-        super(namespace, registry)
-
-        this.storage = this.getStorage()
-        this._isUsingFakeStorage = !isLocalStorageAvailable()
-
-    }
-    
-    getStorage() {
-
-        // Use the isomorphic utility to check localStorage availability
-        if (isLocalStorageAvailable()) {
-            return window.localStorage
-        }
-
-        // Fallback to fake localStorage for SSR or when localStorage is disabled
-        return fakeLocalStorage
-
-    }
-    
-    setNamespace(namespace) {
-        
-        if (!this.namespace) {
-            this.namespace = namespace
-            return
-        }
-        
-        if (this.namespace === namespace)
-            return
-        
-        const items = JSON.parse(JSON.stringify(this.getAll()))
-        
-        this.removeAll()
-        
-        for (const [key, value] of Object.entries(items)) {
-            const newKey = key.replace(this.namespace, namespace)
-            this.setItem(newKey, value)
-        }
-        
-        this.namespace = namespace
-        
-    }
-    
-    getItem(key) {
-        
-        const val = this.storage.getItem(key)
-        
-        if (val === undefined || val === null)
-            return null
-        
-        try {
-            return JSON.parse(val)
-        } catch (e) {
-            return val
-        }
-        
-    }
-    
-    setItem(key, value) {
-        
-        let val = value
-        
-        // Don't allow "null" & similar values to be stringified
-        if (val !== undefined && val !== null)
-            val = isPrimitive(value) ? value : JSON.stringify(value)
-        
-        return this.storage.setItem(key, val)
-        
-    }
-    
-    removeItem(key, fromRegistry = false) {
-        
-        if (fromRegistry)
-            delete this.registry[key]
-        
-        return this.storage.removeItem(key)
-        
-    }
-    
-    getAll() {
-        
-        const prefixNs = `${this.namespace}.`
-        
-        return Object.keys(this.storage).reduce((acc, it) => {
-            
-            if (this.namespace ? it.startsWith(prefixNs) : true)
-                acc[it] = this.storage.getItem(it)
-            
-            return acc
-            
-        }, {})
-        
-    }
-    
-    _resetAll(
-        useInitialValues = true,
-        excludedKeys = [],
-        clearRegistry = false
-    ) {
-
-        const prefixNs = `${this.namespace}.`
-
-        Object.keys(this.storage).forEach(it => {
-
-            const isAppKey = this.namespace ? it.startsWith(prefixNs) : true
-            const isExcluded = excludedKeys?.includes(it) || false
-
-            if (!isAppKey || isExcluded) return
-
-            if (useInitialValues) {
-
-                const isRegistered = Object.prototype.hasOwnProperty.call(this.registry, it)
-
-                if (isRegistered)
-                    this.storage.setItem(it, this.registry[it])
-                else
-                    this.storage.removeItem(it)
-
-            } else {
-
-                this.storage.removeItem(it)
-
-                if (clearRegistry)
-                    delete this.registry[it]
-
-            }
-
-        })
-
-    }
-    
-    resetAll(excludedKeys = [], clearRegistry = false) {
-        this._resetAll(true, excludedKeys || [], clearRegistry)
-    }
-    
-    removeAll(excludedKeys = [], clearRegistry = false) {
-        this._resetAll(false, excludedKeys || [], clearRegistry)
-    }
-
-    /**
-     * Attempt to upgrade from fake storage to real localStorage
-     * This is useful for hydration scenarios
-     */
-    upgradeToRealStorage() {
-
-        if (!this._isUsingFakeStorage) {
-            return false // Already using real storage
-        }
-
-        if (!isLocalStorageAvailable()) {
-            return false // Real storage still not available
-        }
-
-        const fakeData = { ...this.storage }
-        this.storage = window.localStorage
-        this._isUsingFakeStorage = false
-
-        // Migrate data from fake storage to real storage
-        Object.keys(fakeData).forEach(key => {
-            if (key !== '__IS_FAKE_LOCAL_STORAGE__' && fakeData[key] != null) {
-                try {
-                    this.storage.setItem(key, fakeData[key])
-                } catch (e) {
-                    // If we can't write to localStorage, revert to fake storage
-                    this.storage = fakeLocalStorage
-                    this._isUsingFakeStorage = true
-                    return false
-                }
-            }
-        })
-
-        return true
-    }
-
-    /**
-     * Check if currently using fake storage
-     */
-    isUsingFakeStorage() {
-        return this._isUsingFakeStorage
-    }
-
-}
-
-export default LocalStorageProvider

package/src/providers/MemoryStorageProvider.js

@@ -1,20 +0,0 @@
-import LocalStorageProvider from './LocalStorageProvider'
-import { fakeLocalStorage } from '../utils'
-
-class MemoryStorageProvider extends LocalStorageProvider {
-    
-    constructor(namespace = null, registry = {}) {
-        
-        super(namespace, registry)
-        
-    }
-    
-    getStorage() {
-        
-        return fakeLocalStorage
-        
-    }
-    
-}
-
-export default MemoryStorageProvider

package/src/react-wire-persisted.js

@@ -1,136 +0,0 @@
-import { createWire } from '@forminator/react-wire'
-import LocalStorageProvider from './providers/LocalStorageProvider'
-import { getIsClient, getHasHydrated } from './utils'
-
-export const defaultOptions = {
-    logging: {
-        enabled: false,
-    },
-}
-
-let Provider = LocalStorageProvider
-let storage = new Provider()
-let options = { ...defaultOptions }
-let pendingLogs = []
-
-/**
- * Gets the namespace of the storage provider
- * 
- * @returns {String}
- */
-export const getNamespace = () => storage.namespace
-
-/**
- * Gets the current storage provider class instance
- * 
- * @returns {StorageProvider}
- */
-export const getStorage = () => storage
-
-export const getOptions = () => options
-
-/**
- * Sets the namespace for the storage provider
- * 
- * @param {String} namespace The namespace for the storage provider
- */
-export const setNamespace = namespace => {
-    storage.setNamespace(namespace)
-    storage = new Provider(namespace || getNamespace())
-}
-
-export const setOptions = value => {
-    options = {
-        ...options,
-        ...value,
-    }
-    /* istanbul ignore next */
-    if (options.logging.enabled) {
-        console.info('Flushing', pendingLogs.length, 'pending logs')
-        while (pendingLogs.length)
-            /* istanbul ignore next */
-            console.log(...pendingLogs.shift())
-    }
-}
-
-/**
- * Attempts to upgrade the storage provider from fake storage to real localStorage
- * This should be called on the client side after hydration
- *
- * @returns {Boolean} True if upgrade was successful
- */
-export const upgradeStorage = () => {
-    if (!getIsClient()) {
-        return false
-    }
-
-    const upgraded = storage.upgradeToRealStorage()
-
-    if (upgraded) {
-        log('react-wire-persisted: Upgraded to real localStorage after hydration')
-    }
-
-    return upgraded
-}
-
-const log = (...args) => {
-    /* istanbul ignore next */
-    if (options.logging.enabled)
-        /* istanbul ignore next */
-        console.log(...args)
-    else
-        pendingLogs.push(args)
-}
-
-/**
- * Creates a persisted Wire using the `StorageProvider` that is currently set
- * Defaults to `localStorage` via `LocalStorageProvider`
- * 
- * @param {String} key Unique key for storing this value
- * @param {*} value Initial value of this Wire
- * @returns A new Wire decorated with localStorage functionality
- */
-export const createPersistedWire = (key, value = null) => {
-    
-    // This check helps ensure no accidental key typos occur
-    if (!key && (typeof key) !== 'number') throw new Error(
-        `createPersistedWire: Key cannot be a falsey value (${key}}`
-    )
-    
-    // Track this writable entry so we can easily clear all
-    storage.register(key, value)
-    
-    // The actual Wire backing object
-    const wire = createWire(value)
-    
-    const getValue = () => wire.getValue()
-    
-    const setValue = newValue => {
-        storage.setItem(key, newValue)
-        return wire.setValue(newValue)
-    }
-    
-    const subscribe = fn => {
-        wire.subscribe(fn)
-    }
-    
-    const storedValue = storage.getItem(key)
-    const initialValue = storedValue === null ? value : storedValue
-    
-    log('react-wire-persisted: create', key, {
-        value,
-        storedValue,
-        initialValue,
-    })
-    
-    if (initialValue !== value)
-        setValue(initialValue)
-    
-    return {
-        ...wire,
-        getValue,
-        setValue,
-        subscribe,
-    }
-    
-}

package/src/utils/fakeLocalStorage.js

@@ -1,16 +0,0 @@
-
-const storage = {
-    __IS_FAKE_LOCAL_STORAGE__: true,
-}
-
-export const fakeLocalStorage = {
-    getItem: key => storage[key],
-    setItem: (key, value) => {
-        storage[key] = value
-    },
-    removeItem: key => {
-        delete storage[key]
-    },
-    // Make Object.keys() work properly for _resetAll method
-    ...storage
-}

package/src/utils/keys.js

@@ -1,49 +0,0 @@
-
-/**
- * Convenience map of keys
- */
-const storageKeys = {}
-
-/**
- * Adds a key to the keys map
- * 
- * @param {String} value Key name
- */
-export const addKey = value => {
-    storageKeys[value] = value
-}
-
-/**
- * Adds a key to the keys map
- * (Alias for `addKey`)
- * 
- * @param {String} value Key name
- */
-export const key = value => addKey(value)
-
-/**
- * Convenience method to get internally managed storage keys
- * 
- * @returns {Object} Storage keys map
- */
-export const getKeys = () => storageKeys
-
-/**
- * Helper utility to prefix all keys in a map to use a namespace
- * 
- * @param {String} namespace Storage namespace prefix
- * @param {Object} keys (Optional) Storage key/values. Defaults to the internally managed keys map
- */
-export const getPrefixedKeys = (namespace, keys = null) => {
-    
-    const items = keys || storageKeys
-    
-    if (!namespace)
-        return items
-    
-    return Object.keys(items).reduce((acc, it) => ({
-        ...acc,
-        [it]: `${namespace}.${items[it]}`,
-    }), {})
-    
-}