Merge pull request #47 from kaytwo/main

atomic persistentMap.set()

index.js

@@ -7,8 +7,8 @@ let eventsEngine = { addEventListener() {}, removeEventListener() {} }
 function testSupport() {
   try {
     return typeof localStorage !== 'undefined'
+    /* c8 ignore next 4 */
   } catch {
-    /* c8 ignore next 3 */
     // In Privacy Mode access to localStorage will return error
     return false
   }
@@ -89,7 +89,7 @@ export function persistentMap(prefix, initial = {}, opts = {}) {
   let store = map()
 
   let setKey = store.setKey
-  store.setKey = (key, newValue) => {
+  let storeKey = (key, newValue) => {
     if (typeof newValue === 'undefined') {
       if (opts.listen !== false && eventsEngine.perKey) {
         eventsEngine.removeEventListener(prefix + key, listener, restore)
@@ -105,19 +105,24 @@ export function persistentMap(prefix, initial = {}, opts = {}) {
       }
       storageEngine[prefix + key] = encode(newValue)
     }
+  }
+
+  store.setKey = (key, newValue) => {
+    storeKey(key, newValue)
     setKey(key, newValue)
   }
 
   let set = store.set
   store.set = function (newObject) {
     for (let key in newObject) {
-      store.setKey(key, newObject[key])
+      storeKey(key, newObject[key])
     }
     for (let key in store.value) {
       if (!(key in newObject)) {
-        store.setKey(key)
+        storeKey(key, undefined)
       }
     }
+    set(newObject)
   }
 
   function listener(e) {
@@ -139,7 +144,9 @@ export function persistentMap(prefix, initial = {}, opts = {}) {
         data[key.slice(prefix.length)] = decode(storageEngine[key])
       }
     }
-    store.set(data)
+    for (let key in data) {
+      store.setKey(key, data[key])
+    }
   }
 
   onMount(store, () => {

test/map.test.ts

@@ -1,7 +1,7 @@
 import './setup.js'
 
 import { delay } from 'nanodelay'
-import { cleanStores, type MapStore } from 'nanostores'
+import { cleanStores, type MapStore, map as nanoMap } from 'nanostores'
 import { deepStrictEqual, equal } from 'node:assert'
 import { afterEach, test } from 'node:test'
 
@@ -52,22 +52,11 @@ test('saves to localStorage', () => {
 
   map.set({ one: '11' })
   deepStrictEqual(localStorage, { 'b:one': '11' })
-  deepStrictEqual(events, [
-    { one: '1' },
-    { one: '1', two: '2' },
-    { one: '11', two: '2' },
-    { one: '11' }
-  ])
+  deepStrictEqual(events, [{ one: '1' }, { one: '1', two: '2' }, { one: '11' }])
 
   map.setKey('one', undefined)
   deepStrictEqual(localStorage, {})
-  deepStrictEqual(events, [
-    { one: '1' },
-    { one: '1', two: '2' },
-    { one: '11', two: '2' },
-    { one: '11' },
-    {}
-  ])
+  deepStrictEqual(events, [{ one: '1' }, { one: '1', two: '2' }, { one: '11' }, {}])
 })
 
 test('listens for other tabs', () => {
@@ -249,3 +238,41 @@ test('supports per key engine', async () => {
   await delay(1010)
   deepStrictEqual(Object.keys(listeners), [])
 })
+
+test('emits one event per update', () => {
+  map = persistentMap<{ one?: string; two?: string }>('1:', {
+    one: '1',
+    two: '2'
+  })
+
+  let events: object[] = []
+  map.listen(value => {
+    events.push(clone(value))
+  })
+  map.set({ one: '2', two: '3' })
+
+  equal(events.length, 1)
+  deepStrictEqual(map.get(), { one: '2', two: '3' })
+})
+
+test('emits equally many events per update compared to non-persistent map', () => {
+  map = persistentMap<{ one?: string; two?: string }>('1:', {
+    one: '1',
+    two: '2'
+  })
+  let nano = nanoMap({ one: '1', two: '2' })
+
+  let events: object[] = []
+  let nanoEvents: object[] = []
+  map.listen(value => {
+    events.push(clone(value))
+  })
+  nano.listen(value => {
+    nanoEvents.push(clone(value))
+  })
+  map.set({ one: '2', two: '3' })
+  nano.set({ one: '2', two: '3' })
+
+  deepStrictEqual(map.get(), nano.get())
+  equal(events.length, nanoEvents.length)
+})