consistently handle falsy store values for derived, add tests

src/runtime/internal/utils.ts

@@ -69,7 +69,7 @@ export function validate_store(store, name) {
 export function subscribe(store, ...callbacks) {
 	if (store == null) {
 		for (const callback of callbacks) {
-			callback(store);
+			callback(undefined);
 		}
 		return noop;
 	}

src/runtime/store/index.ts

@@ -165,8 +165,9 @@ export function derived<S extends Stores, T>(
 export function derived<T>(stores: Stores, fn: Function, initial_value?: T): Readable<T> {
 	const single = !Array.isArray(stores);
 	const stores_array: Array<Readable<any>> = single
-		? [stores as Readable<any>]
+		// Fall back to readable() for falsy stores in array, else derived store will be forever pending
-		: stores as Array<Readable<any>>;
+		? [(stores || readable()) as Readable<any>]
+		: (stores as Array<Readable<any>>).map(store => store || readable());
 
 	const auto = fn.length < 2;
 

test/store/index.js

@@ -428,6 +428,39 @@ describe('store', () => {
 			a.set(false);
 			assert.equal(b_started, false);
 		});
+
+		it('works with undefined stores #1', () => {
+			const a = derived(null, (n) => {
+				return n;
+			});
+			const values = [];
+			const unsubscribe = a.subscribe((value) => values.push(value));
+			unsubscribe();
+			assert.deepEqual(values, [undefined]);
+		});
+
+		it('works with undefined stores #2', () => {
+			const a = writable(1);
+			const b = derived([a, null, undefined], ([n, un1, un2]) => {
+				assert.equal(un1, undefined);
+				assert.equal(un2, undefined);
+				return n * 2;
+			});
+
+			const values = [];
+
+			const unsubscribe = b.subscribe(value => {
+				values.push(value);
+			});
+
+			a.set(2);
+			assert.deepEqual(values, [2, 4]);
+
+			unsubscribe();
+
+			a.set(3);
+			assert.deepEqual(values, [2, 4]);
+		});
 	});
 
 	describe('get', () => {