Add skipVoid to maps and combines

src/and/index.ts

@@ -1,12 +1,16 @@
 import { combine, Store } from 'effector';
 
 export function and(...stores: Array<Store<any>>): Store<boolean> {
-  return combine(stores, (values) => {
-    for (const value of values) {
-      if (!value) {
-        return false;
+  return combine(
+    stores,
+    (values) => {
+      for (const value of values) {
+        if (!value) {
+          return false;
+        }
       }
-    }
-    return true;
-  }) as Store<boolean>;
+      return true;
+    },
+    { skipVoid: false },
+  ) as Store<boolean>;
 }

src/combine-events/index.ts

@@ -96,7 +96,7 @@ export function combineEvents<P>({
 
     sample({
       source: eventsTrriggered,
-      filter: $counter.map((value) => value === 0),
+      filter: $counter.map((value) => value === 0, { skipVoid: false }),
       target: target as UnitTargetable<any>,
     });
   });

src/condition/index.ts

@@ -1,4 +1,14 @@
-import { createEvent, Effect, Event, sample, is, Store, Unit, UnitTargetable, split } from 'effector';
+import {
+  createEvent,
+  Effect,
+  Event,
+  sample,
+  is,
+  Store,
+  Unit,
+  UnitTargetable,
+  split,
+} from 'effector';
 
 type NoInfer<T> = T & { [K in keyof T]: T[K] };
 type EventAsReturnType<Payload> = any extends Payload ? Event<Payload> : never;
@@ -120,7 +130,7 @@ function inverse<A extends boolean, T>(
   fnOrUnit: Store<boolean> | ((payload: T) => boolean),
 ): Store<boolean> | ((payload: T) => boolean) {
   if (is.unit(fnOrUnit)) {
-    return fnOrUnit.map((value) => !value);
+    return fnOrUnit.map((value) => !value, { skipVoid: false });
   }
   return (value) => !fnOrUnit(value);
 }

src/either/index.ts

@@ -64,6 +64,7 @@ export function either<Then, Other>(
       then as Store<Then>,
       other as Store<Other>,
       (filter, then, other) => (filter ? then : other),
+      { skipVoid: false },
     );
   }
 

src/empty/index.ts

@@ -1,5 +1,5 @@
 import { Store } from 'effector';
 
 export function empty<A>(source: Store<A | null | undefined>): Store<boolean> {
-  return source.map((value) => value == null);
+  return source.map((value) => value == null, { skipVoid: false });
 }

src/equals/index.ts

@@ -25,5 +25,7 @@ export function equals<A, B>(
     ? B
     : { error: 'argument b should extends a' },
 ): Store<boolean> {
-  return combine(a as Store<A>, b as Store<A>, (a, b) => a === b);
+  return combine(a as Store<A>, b as Store<A>, (a, b) => a === b, {
+    skipVoid: false,
+  });
 }

src/every/index.ts

@@ -51,7 +51,9 @@ export function every<T>(
   if (isFunction(predicate)) {
     checker = predicate;
   } else if (is.store(predicate)) {
-    checker = predicate.map((value) => (required: T) => value === required);
+    checker = predicate.map((value) => (required: T) => value === required, {
+      skipVoid: false,
+    });
   } else {
     checker = (value: T) => value === predicate;
   }
@@ -60,7 +62,9 @@ export function every<T>(
   // Combine pass simple values as is
   const $checker = checker as Store<(value: T) => boolean>;
 
-  return combine($checker, $values, (checker, values) => values.every(checker));
+  return combine($checker, $values, (checker, values) => values.every(checker), {
+    skipVoid: false,
+  });
 }
 
 function isFunction<T>(value: unknown): value is (value: T) => boolean {

src/format/index.ts

@@ -15,16 +15,19 @@ export function format<Values extends StoreOrValue<any>[]>(
   strings: TemplateStringsArray,
   ...stores: [...Values]
 ): Store<string> {
-  return combine(stores, (stores) =>
-    strings.reduce(
-      (acc, value, index) =>
-        acc.concat(
-          isLastElement(strings, index)
-            ? value
-            : `${value}${toString(stores[index])}`,
-        ),
-      '',
-    ),
+  return combine(
+    stores,
+    (stores) =>
+      strings.reduce(
+        (acc, value, index) =>
+          acc.concat(
+            isLastElement(strings, index)
+              ? value
+              : `${value}${toString(stores[index])}`,
+          ),
+        '',
+      ),
+    { skipVoid: false },
   );
 }
 

src/in-flight/index.ts

@@ -22,5 +22,6 @@ export function inFlight({
   return combine(
     effects!.map((fx) => fx.inFlight),
     (inFlights) => inFlights.reduce((all, current) => all + current, 0),
+    { skipVoid: false },
   );
 }

src/interval/index.ts

@@ -1,12 +1,4 @@
-import {
-  Event,
-  Store,
-  createEvent,
-  createStore,
-  sample,
-  attach,
-  is,
-} from 'effector';
+import { Event, Store, createEvent, createStore, sample, attach, is } from 'effector';
 
 export function interval<S extends unknown, F extends unknown>(config: {
   timeout: number | Store<number>;
@@ -42,7 +34,7 @@ export function interval<S extends unknown, F extends unknown>({
   const $isRunning = createStore(false);
   const $timeout = toStoreNumber(timeout);
 
-  const $notRunning = $isRunning.map((running) => !running);
+  const $notRunning = $isRunning.map((running) => !running, { skipVoid: false });
 
   const saveTimeout = createEvent<{
     timeoutId: NodeJS.Timeout;

src/not/index.ts

@@ -1,5 +1,5 @@
 import { Store } from 'effector';
 
 export function not<T extends unknown>(source: Store<T>): Store<boolean> {
-  return source.map((value) => !value);
+  return source.map((value) => !value, { skipVoid: false });
 }

src/or/index.ts

@@ -1,12 +1,16 @@
 import { combine, Store } from 'effector';
 
 export function or(...stores: Array<Store<any>>): Store<boolean> {
-  return combine(stores, (values) => {
-    for (const value of values) {
-      if (value) {
-        return true;
+  return combine(
+    stores,
+    (values) => {
+      for (const value of values) {
+        if (value) {
+          return true;
+        }
       }
-    }
-    return false;
-  }) as Store<boolean>;
+      return false;
+    },
+    { skipVoid: false },
+  ) as Store<boolean>;
 }

src/pending/index.ts

@@ -40,5 +40,6 @@ export function pending({
   return combine(
     effects.map((fx) => fx.pending),
     strategy,
+    { skipVoid: false },
   );
 }

src/reshape/index.ts

@@ -23,10 +23,13 @@ export function reshape<Type, Shape extends Record<string, unknown>>({
     }
 
     const fn = shape[key];
-    result[key] = source.map((state) => {
-      const result = fn(state);
-      return result === undefined ? null : result;
-    });
+    result[key] = source.map(
+      (state) => {
+        const result = fn(state);
+        return result === undefined ? null : result;
+      },
+      { skipVoid: false },
+    );
   }
 
   return result as any;

src/some/index.ts

@@ -48,7 +48,9 @@ export function some<T>(
   if (isFunction(predicate)) {
     checker = predicate;
   } else if (is.store(predicate)) {
-    checker = predicate.map((value) => (required: T) => value === required);
+    checker = predicate.map((value) => (required: T) => value === required, {
+      skipVoid: false,
+    });
   } else {
     checker = (value: T) => value === predicate;
   }
@@ -57,7 +59,9 @@ export function some<T>(
   // Combine pass simple values as is
   const $checker = checker as Store<(value: T) => boolean>;
 
-  return combine($checker, $values, (checker, values) => values.some(checker));
+  return combine($checker, $values, (checker, values) => values.some(checker), {
+    skipVoid: false,
+  });
 }
 
 function isFunction<T>(value: unknown): value is (value: T) => boolean {