Use UnitTargetable

src/combine-events/index.ts

@@ -9,6 +9,7 @@ import {
   sample,
   Store,
   Unit,
+  UnitTargetable,
   withRegion,
 } from 'effector';
 
@@ -40,7 +41,7 @@ export function combineEvents<P extends Shape>(config: {
 
 export function combineEvents<
   P extends Shape,
-  T extends Unit<P extends Tuple ? P : Partial<P>>,
+  T extends UnitTargetable<P extends Tuple ? P : Partial<P>>,
 >(config: { events: Events<P>; target: T; reset?: Unit<any> }): ReturnTarget<P, T>;
 
 export function combineEvents<P>({
@@ -50,9 +51,10 @@ export function combineEvents<P>({
 }: {
   events: Events<P>;
   reset?: Unit<any>;
-  target?: Unit<any>;
+  target?: UnitTargetable<any> | Unit<any>;
 }) {
-  if (!is.unit(target)) throwError('target should be a unit');
+  if (!(is.unit(target) && is.targetable(target)))
+    throwError('target should be a targetable unit');
   if (reset && !is.unit(reset)) throwError('reset should be a unit');
 
   withRegion(target, () => {
@@ -87,10 +89,15 @@ export function combineEvents<P>({
       });
     }
 
+    const eventsTrriggered = sample({
+      source: $results,
+      clock: [...(Object.values(events) as Unit<any>[])],
+    });
+
     sample({
-      source: sample({ source: $results, clock: merge(Object.values(events)) }),
+      source: eventsTrriggered,
       filter: $counter.map((value) => value === 0),
-      target,
+      target: target as UnitTargetable<any>,
     });
   });
 

src/condition/index.ts

@@ -1,57 +1,57 @@
-import { createEvent, Effect, Event, sample, is, Store, Unit, 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;
 
 export function condition<State>(options: {
   source: Event<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  then: Unit<NoInfer<State> | void>;
-  else: Unit<NoInfer<State> | void>;
+  then: UnitTargetable<NoInfer<State> | void>;
+  else: UnitTargetable<NoInfer<State> | void>;
 }): EventAsReturnType<State>;
 export function condition<State>(options: {
   source: Store<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  then: Unit<State | void>;
-  else: Unit<State | void>;
+  then: UnitTargetable<State | void>;
+  else: UnitTargetable<State | void>;
 }): Store<State>;
 export function condition<Params, Done, Fail>(options: {
   source: Effect<Params, Done, Fail>;
   if: ((payload: Params) => boolean) | Store<boolean> | Params;
-  then: Unit<NoInfer<Params> | void>;
-  else: Unit<NoInfer<Params> | void>;
+  then: UnitTargetable<NoInfer<Params> | void>;
+  else: UnitTargetable<NoInfer<Params> | void>;
 }): Effect<Params, Done, Fail>;
 
 export function condition<State>(options: {
   source: Event<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  then: Unit<NoInfer<State> | void>;
+  then: UnitTargetable<NoInfer<State> | void>;
 }): EventAsReturnType<State>;
 export function condition<State>(options: {
   source: Store<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  then: Unit<NoInfer<State> | void>;
+  then: UnitTargetable<NoInfer<State> | void>;
 }): Store<State>;
 export function condition<Params, Done, Fail>(options: {
   source: Effect<Params, Done, Fail>;
   if: ((payload: Params) => boolean) | Store<boolean> | Params;
-  then: Unit<NoInfer<Params> | void>;
+  then: UnitTargetable<NoInfer<Params> | void>;
 }): Effect<Params, Done, Fail>;
 
 export function condition<State>(options: {
   source: Event<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  else: Unit<NoInfer<State> | void>;
+  else: UnitTargetable<NoInfer<State> | void>;
 }): EventAsReturnType<State>;
 export function condition<State>(options: {
   source: Store<State>;
   if: ((payload: State) => boolean) | Store<boolean> | State;
-  else: Unit<NoInfer<State> | void>;
+  else: UnitTargetable<NoInfer<State> | void>;
 }): Store<State>;
 export function condition<Params, Done, Fail>(options: {
   source: Effect<Params, Done, Fail>;
   if: ((payload: Params) => boolean) | Store<boolean> | Params;
-  else: Unit<NoInfer<Params> | void>;
+  else: UnitTargetable<NoInfer<Params> | void>;
 }): Effect<Params, Done, Fail>;
 
 // Without `source`

src/debounce/index.ts

@@ -2,52 +2,38 @@ import {
   createEffect,
   createEvent,
   createStore,
-  Event,
   is,
   sample,
   Store,
   Unit,
   attach,
   merge,
-  Effect,
+  UnitTargetable,
+  EventAsReturnType
 } from 'effector';
 
-type EventAsReturnType<Payload> = any extends Payload ? Event<Payload> : never;
-
 export function debounce<T>(_: {
-  source: Event<T> | Effect<T, any, any> | Store<T>;
+  source: Unit<T>;
   timeout: number | Store<number>;
-  name?: string;
 }): EventAsReturnType<T>;
 export function debounce<
   T,
   Target extends
-    | Event<T>
-    | Event<void>
-    | Effect<T, any, any>
-    | Effect<void, any, any>
-    | Store<T>,
+    | UnitTargetable<T>
+    | UnitTargetable<void>,
 >(_: {
-  source: Event<T> | Effect<T, any, any> | Store<T>;
+  source: Unit<T>;
   timeout: number | Store<number>;
   target: Target;
-  name?: string;
 }): Target;
 export function debounce<T>({
   source,
   timeout,
   target,
 }: {
-  source: Event<T> | Effect<T, any, any> | Store<T>;
+  source: Unit<T>;
   timeout?: number | Store<number>;
-  /** @deprecated */
-  name?: string;
-  target?:
-    | Event<T>
-    | Event<void>
-    | Effect<T, any, any>
-    | Effect<void, any, any>
-    | Store<T>;
+  target?: UnitTargetable<T> | Unit<T>
 }): typeof target extends undefined ? EventAsReturnType<T> : typeof target {
   if (!is.unit(source)) throw new TypeError('source must be unit from effector');
 
@@ -65,7 +51,7 @@ export function debounce<T>({
     serialize: 'ignore',
   }).on(saveReject, (_, rj) => rj);
 
-  const tick: Unit<T | void> = target ?? createEvent();
+  const tick = (target as UnitTargetable<T>) ?? createEvent();
 
   const timerBaseFx = createEffect<
     {
@@ -83,7 +69,7 @@ export function debounce<T>({
     });
   });
   const timerFx = attach({
-    name: `debounce(${source.shortName || source.kind}) effect`,
+    name: `debounce(${(source as any)?.shortName || source.kind}) effect`,
     source: {
       timeoutId: $timeoutId,
       rejectPromise: $rejecter,

src/delay/index.ts

@@ -10,6 +10,7 @@ import {
   Target as TargetType,
   MultiTarget,
   UnitValue,
+  UnitTargetable,
 } from 'effector';
 
 type TimeoutType<Payload> = ((payload: Payload) => number) | Store<number> | number;
@@ -68,7 +69,7 @@ export function delay<
     target: timerFx,
   });
 
-  sample({ clock: timerFx.doneData, target: targets as Unit<any>[] });
+  sample({ clock: timerFx.doneData, target: targets as UnitTargetable<any>[] });
 
   return target as any;
 }

src/once/index.ts

@@ -1,25 +1,21 @@
 import {
   Unit,
-  Store,
   Event,
-  Effect,
   EventAsReturnType,
   is,
   sample,
   createStore,
 } from 'effector';
 
-type SourceType<T> = Event<T> | Effect<T, any, any> | Store<T>;
-
 export function once<T>(config: {
-  source: SourceType<T>;
-  reset?: SourceType<any>;
+  source: Unit<T>;
+  reset?: Unit<any>;
 }): EventAsReturnType<T>;
 
-export function once<T>(unit: SourceType<T>): EventAsReturnType<T>;
+export function once<T>(unit: Unit<T>): EventAsReturnType<T>;
 
 export function once<T>(
-  unitOrConfig: { source: SourceType<T>; reset?: SourceType<any> } | SourceType<T>,
+  unitOrConfig: { source: Unit<T>; reset?: Unit<any> } | Unit<T>,
 ): EventAsReturnType<T> {
   let source: Unit<T>;
   let reset: Unit<any> | undefined;

src/reset/index.ts

@@ -1,10 +1,10 @@
 import { createEvent } from 'effector';
 
-import type { Event, Unit, Store } from 'effector';
+import type { Event, Unit, Store, StoreWritable } from 'effector';
 
 type Params = {
   clock?: Unit<any> | Array<Unit<any>>;
-  target: Store<any> | Array<Store<any>>;
+  target: StoreWritable<any> | Array<StoreWritable<any>>;
 };
 
 export function reset(config: Required<Params>): void;

src/spread/index.ts

@@ -1,4 +1,4 @@
-import { createEvent, Event, sample, Unit } from 'effector';
+import { createEvent, Event, EventCallable, sample, Unit, UnitTargetable } from 'effector';
 
 const hasPropBase = {}.hasOwnProperty;
 const hasOwnProp = <O extends { [k: string]: unknown }>(object: O, key: string) =>
@@ -9,7 +9,7 @@ type EventAsReturnType<Payload> = any extends Payload ? Event<Payload> : never;
 
 export function spread<Payload>(config: {
   targets: {
-    [Key in keyof Payload]?: Unit<Payload[Key]>;
+    [Key in keyof Payload]?: UnitTargetable<Payload[Key]>;
   };
 }): EventAsReturnType<Partial<Payload>>;
 
@@ -20,8 +20,8 @@ export function spread<
   source: Source;
   targets: {
     [Key in keyof Payload]?:
-      | EventAsReturnType<Partial<Payload[Key]>>
-      | Unit<NoInfer<Payload[Key]>>;
+      | EventCallable<Partial<Payload[Key]>>
+      | UnitTargetable<NoInfer<Payload[Key]>>;
   };
 }): Source;
 
@@ -56,7 +56,7 @@ export function spread<P>({
         batch: false,
         clock: hasTargetKey,
         fn: (object: P) => object[targetKey],
-        target: currentTarget as Unit<any>,
+        target: currentTarget as UnitTargetable<any>,
       });
     }
   }

src/throttle/index.ts

@@ -7,6 +7,7 @@ import {
   sample,
   Store,
   Unit,
+  UnitTargetable,
 } from 'effector';
 
 type EventAsReturnType<Payload> = any extends Payload ? Event<Payload> : never;
@@ -16,7 +17,7 @@ export function throttle<T>(_: {
   timeout: number | Store<number>;
   name?: string;
 }): EventAsReturnType<T>;
-export function throttle<T, Target extends Unit<T>>(_: {
+export function throttle<T, Target extends UnitTargetable<T>>(_: {
   source: Unit<T>;
   timeout: number | Store<number>;
   target: Target;
@@ -30,7 +31,7 @@ export function throttle<T>({
   source: Unit<T>;
   timeout: number | Store<number>;
   name?: string;
-  target?: Unit<any>;
+  target?: UnitTargetable<any>;
 }): EventAsReturnType<T> {
   if (!is.unit(source)) throw new TypeError('source must be unit from effector');