Restrict observer keys argument to accept only arrays

The interface becomes more stable, and if by any reason I need
to lift the restriction later, it will not be a breaking change.
The reverse situation would break compatibility, so this is the
safest bet.

src/true-store.js

@@ -65,14 +65,13 @@ class TrueStore {
             this.notifyObservers(oldMap, this.stateMap);
     }
 
-    observer(callback, keys = null) {
-        if (keys === null)
-            keys = [];
-        keys = Array.isArray(keys) ? keys : [keys];
-        keys.map((key) => {
-            if (typeof(key) !== 'string')
-                throw Error('TrueStore.observer: keys must be strings.');
-        });
+    observer(callback, keys = []) {
+        let err = 'TrueStore.observer: keys must be an array of strings.';
+        if (!Array.isArray(keys))
+            throw Error(err);
+        for (let i in keys)
+            if (typeof(keys[i]) !== 'string')
+                throw Error(err);
         let observer = new TrueStoreObserver(this, keys, callback);
         this.observers.push(observer);
         return observer;

tests/del.test.js

@@ -30,15 +30,15 @@ describe('del', () => {
     it('trigger observers while outside transactions', () => {
         let store = new TrueStore({foo: 42});
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.del('foo');
         expect(callback.mock.calls.length).toBe(1);
     });
 
     it('does not trigger observers inside a transaction', () => {
         let store = new TrueStore({foo: 42});
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.transaction(() => {
             store.del('foo');
             expect(callback.mock.calls.length).toBe(0);

tests/observer.test.js

@@ -21,7 +21,7 @@ describe('observer', () => {
     it('allows a callback to observe a specific key in the store', () => {
         let store = new TrueStore({foo: 42, bar: 42});
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.set('foo', 43);
         store.set('bar', 43);
         expect(callback.mock.calls.length).toBe(1);
@@ -40,7 +40,7 @@ describe('observer', () => {
     it('allows a callback to observe a nested key in the store', () => {
         let store = new TrueStore({foo: {foo: 42, bar: 42}});
         let callback = jest.fn();
-        store.observer(callback, 'foo.bar');
+        store.observer(callback, ['foo.bar']);
         store.set('foo.foo', 43);
         store.set('foo.bar', 43);
         expect(callback.mock.calls.length).toBe(1);
@@ -71,13 +71,20 @@ describe('observer', () => {
         let store = new TrueStore({foo: 42});
         expect(() => {
             store.observer(jest.fn(), 42);
-        }).toThrow('TrueStore.observer: keys must be strings.');
+        }).toThrow('TrueStore.observer: keys must be an array of strings.');
     });
 
     it('throws exception if one of the keys is invalid', () => {
         let store = new TrueStore({foo: 42});
         expect(() => {
             store.observer(jest.fn(), ['foo', 'bar', 42]);
-        }).toThrow('TrueStore.observer: keys must be strings.');
+        }).toThrow('TrueStore.observer: keys must be an array of strings.');
+    });
+
+    it('throws exception if the keys argument is not an array', () => {
+        let store = new TrueStore({foo: 42});
+        expect(() => {
+            store.observer(jest.fn(), 'foo');
+        }).toThrow('TrueStore.observer: keys must be an array of strings.');
     });
 });

tests/reset.test.js

@@ -14,15 +14,15 @@ describe('reset', () => {
         let store = new TrueStore({foo: 42});
         store.set('foo', 43);
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.reset();
         expect(callback.mock.calls.length).toBe(1);
     });
 
     it('does not trigger observers if nothing changes', () => {
         let store = new TrueStore({foo: 42});
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.reset();
         expect(callback.mock.calls.length).toBe(0);
     });
@@ -31,7 +31,7 @@ describe('reset', () => {
         let store = new TrueStore({foo: 42});
         store.set('foo', 43);
         let callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.transaction(() => {
             store.reset();
             expect(callback.mock.calls.length).toBe(0);

tests/set.test.js

@@ -24,15 +24,15 @@ describe('set', () => {
     it('triggers data listeners', () => {
         let store = new TrueStore({foo: null});
         callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.set('foo', 'bar');
         expect(callback).toHaveBeenCalled();
     });
 
     it('triggers data listeners from nested changes', () => {
         let store = new TrueStore({foo: {bar: null}});
         callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.set('foo.bar', 42);
         expect(callback).toHaveBeenCalled();
     });

tests/transaction.test.js

@@ -5,7 +5,7 @@ describe('transaction', () => {
     it('prevents listeners from running multiple times inside the transaction', () => {
         let store = new TrueStore({foo: 42});
         callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.transaction(() => {
             store.set('foo', 43);
             store.set('foo', 44);
@@ -17,7 +17,7 @@ describe('transaction', () => {
     it('prevents listener calls inside nest transactions', () => {
         let store = new TrueStore({foo: 42});
         callback = jest.fn();
-        store.observer(callback, 'foo');
+        store.observer(callback, ['foo']);
         store.transaction(() => {
             store.set('foo', 43);
             store.transaction(() => {