From 520a790a1f7a75c882ad80c030dc7d60b31180e4 Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Tue, 23 Apr 2024 02:07:11 +0300
Subject: [PATCH 1/6] feat: expose timers api

---
 src/debounce/debounce.fork.test.ts | 43 ++++++++++++++--
 src/debounce/index.ts              | 57 ++++++++++++++-------
 src/debounce/readme.md             | 22 ++++++++
 src/delay/delay.fork.test.ts       | 45 ++++++++++++++++-
 src/delay/index.ts                 | 37 ++++++++------
 src/delay/readme.md                | 21 ++++++++
 src/interval/index.ts              | 80 ++++++++++++++++++++----------
 src/interval/interval.fork.test.ts | 53 ++++++++++++++++++--
 src/interval/readme.md             | 35 +++++++++++++
 src/throttle/index.ts              | 28 +++++++----
 src/throttle/readme.md             | 18 +++++++
 src/throttle/throttle.fork.test.ts | 36 +++++++++++++-
 src/time/index.ts                  | 31 +++++++++---
 src/time/readme.md                 | 17 +++++++
 src/time/time.fork.test.ts         | 31 +++++++++++-
 src/time/time.test.ts              |  1 +
 16 files changed, 470 insertions(+), 85 deletions(-)

diff --git a/src/debounce/debounce.fork.test.ts b/src/debounce/debounce.fork.test.ts
index 130d076f..8de77172 100644
--- a/src/debounce/debounce.fork.test.ts
+++ b/src/debounce/debounce.fork.test.ts
@@ -7,11 +7,11 @@ import {
   createEvent,
   createStore,
   sample,
-  createWatch,
-} from 'effector';
+  createWatch, createEffect,
+} from 'effector'
 import { wait, watch } from '../../test-library';
 
-import { debounce } from './index';
+import { debounce, DebounceTimerFxProps } from './index'
 
 test('debounce works in forked scope', async () => {
   const app = createDomain();
@@ -232,3 +232,40 @@ describe('edge cases', () => {
     expect(triggerListener).toBeCalledTimes(0);
   })
 });
+
+test('exposed timers api', async () => {
+  const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
+    if (timeoutId) clearTimeout(timeoutId);
+    if (rejectPromise) rejectPromise();
+    return new Promise((resolve, reject) => {
+      saveCancel([setTimeout(resolve, timeout / 2), reject]);
+    });
+  });
+
+  const scope = fork({
+    handlers: [
+      [debounce.timerFx, timerFx],
+    ]
+  });
+
+  const mockedFn = jest.fn();
+
+  const clock = createEvent();
+  const tick = debounce(clock, 50);
+
+  createWatch({
+    unit: tick,
+    fn: mockedFn,
+    scope,
+  });
+
+  allSettled(clock, { scope });
+
+  await wait(20);
+
+  expect(mockedFn).not.toBeCalled();
+
+  await wait(5);
+
+  expect(mockedFn).toBeCalled();
+});
diff --git a/src/debounce/index.ts b/src/debounce/index.ts
index f0a21a82..d52d0981 100644
--- a/src/debounce/index.ts
+++ b/src/debounce/index.ts
@@ -9,18 +9,34 @@ import {
   merge,
   UnitTargetable,
   EventAsReturnType,
-} from 'effector';
+  createEffect, EventCallable
+} from 'effector'
+
+export type DebounceTimerFxProps = {
+  timeoutId?: NodeJS.Timeout;
+  rejectPromise?: () => void;
+  saveCancel: EventCallable<[NodeJS.Timeout, () => void]>;
+  timeout: number;
+};
+
+const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
+  if (timeoutId) clearTimeout(timeoutId);
+  if (rejectPromise) rejectPromise();
+  return new Promise((resolve, reject) => {
+    saveCancel([setTimeout(resolve, timeout), reject]);
+  });
+});
 
-export function debounce<T>(
+export function _debounce<T>(
   source: Unit<T>,
   timeout: number | Store<number>,
 ): EventAsReturnType<T>;
-export function debounce<T>(_: {
+export function _debounce<T>(_: {
   source: Unit<T>;
   timeout: number | Store<number>;
   name?: string;
 }): EventAsReturnType<T>;
-export function debounce<
+export function _debounce<
   T,
   Target extends UnitTargetable<T> | UnitTargetable<void>,
 >(_: {
@@ -29,7 +45,7 @@ export function debounce<
   target: Target;
   name?: string;
 }): Target;
-export function debounce<T>(
+export function _debounce<T>(
   ...args:
     | [
         {
@@ -57,18 +73,19 @@ export function debounce<T>(
 
   const tick = (target as UnitTargetable<T>) ?? createEvent();
 
-  const timerFx = attach({
+  const innerTimerFx = attach({
     name: name || `debounce(${(source as any)?.shortName || source.kind}) effect`,
     source: $canceller,
-    effect([timeoutId, rejectPromise], timeout: number) {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (rejectPromise) rejectPromise();
-      return new Promise((resolve, reject) => {
-        saveCancel([setTimeout(resolve, timeout), reject]);
-      });
-    },
+    mapParams: (timeout: number, [timeoutId, rejectPromise]) => ({
+      timeout,
+      timeoutId,
+      rejectPromise,
+      saveCancel
+    }),
+    effect: timerFx,
   });
-  $canceller.reset(timerFx.done);
+
+  $canceller.reset(innerTimerFx.done);
 
   // It's ok - nothing will ever start unless source is triggered
   const $payload = createStore<T[]>([], { serialize: 'ignore', skipVoid: false }).on(
@@ -88,7 +105,7 @@ export function debounce<T>(
         // debounce timeout should be restarted on timeout change
         $timeout,
         // debounce timeout can be restarted in later ticks
-        timerFx,
+        innerTimerFx,
       ],
       () => true,
     );
@@ -96,7 +113,7 @@ export function debounce<T>(
   const requestTick = merge([
     source,
     // debounce timeout is restarted on timeout change
-    sample({ clock: $timeout, filter: timerFx.pending }),
+    sample({ clock: $timeout, filter: innerTimerFx.pending }),
   ]);
 
   sample({
@@ -108,12 +125,12 @@ export function debounce<T>(
   sample({
     source: $timeout,
     clock: triggerTick,
-    target: timerFx,
+    target: innerTimerFx,
   });
 
   sample({
     source: $payload,
-    clock: timerFx.done,
+    clock: innerTimerFx.done,
     fn: ([payload]) => payload,
     target: tick,
   });
@@ -121,6 +138,10 @@ export function debounce<T>(
   return tick as any;
 }
 
+export const debounce = Object.assign(_debounce, {
+  timerFx
+});
+
 function toStoreNumber(value: number | Store<number> | unknown): Store<number> {
   if (is.store(value)) return value;
   if (typeof value === 'number') {
diff --git a/src/debounce/readme.md b/src/debounce/readme.md
index 4182cfb9..e4bfd6a1 100644
--- a/src/debounce/readme.md
+++ b/src/debounce/readme.md
@@ -197,3 +197,25 @@ someHappened(4);
 
 // someHappened now 4
 ```
+
+### [Tests] Exposed timers API example
+
+```ts
+const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
+  if (timeoutId) myClearTimeout(timeoutId);
+  if (rejectPromise) rejectPromise();
+  return new Promise((resolve, reject) => {
+    saveCancel([mySetTimeout(resolve, timeout), reject]);
+  });
+});
+
+const scope = fork({
+  handlers: [[debounce.timerFx, timerFx]],
+});
+
+const clock = createEvent();
+const tick = debounce(clock, 200);
+
+// important! call from scope
+allSettled(clock, { scope });
+```
diff --git a/src/delay/delay.fork.test.ts b/src/delay/delay.fork.test.ts
index d5f62c8b..ccbe709b 100644
--- a/src/delay/delay.fork.test.ts
+++ b/src/delay/delay.fork.test.ts
@@ -1,7 +1,14 @@
 import 'regenerator-runtime/runtime';
-import { createDomain, fork, serialize, allSettled } from 'effector';
+import {
+  createDomain,
+  fork,
+  serialize,
+  allSettled,
+  createEffect, createEvent, createWatch, UnitValue
+} from 'effector'
 
-import { delay } from './index';
+import { delay, DelayTimerFxProps } from './index'
+import { wait } from '../../test-library'
 
 test('throttle works in forked scope', async () => {
   const app = createDomain();
@@ -127,3 +134,37 @@ test('throttle do not affect original store value', async () => {
 
   expect($counter.getState()).toMatchInlineSnapshot(`0`);
 });
+
+test('exposed timers api', async () => {
+  const timerFx = createEffect<DelayTimerFxProps, UnitValue<any>>(
+    ({ payload, milliseconds }) =>
+      new Promise((resolve) => {
+        setTimeout(resolve, milliseconds / 2, payload);
+      }),
+  )
+
+  const scope = fork({
+    handlers: [[delay.timerFx, timerFx]],
+  });
+
+  const mockedFn = jest.fn();
+
+  const clock = createEvent();
+  const tick = delay(clock, 50);
+
+  createWatch({
+    unit: tick,
+    fn: mockedFn,
+    scope,
+  });
+
+  allSettled(clock, { scope });
+
+  await wait(20);
+
+  expect(mockedFn).not.toBeCalled();
+
+  await wait(5);
+
+  expect(mockedFn).toBeCalled();
+});
diff --git a/src/delay/index.ts b/src/delay/index.ts
index 543a4e31..37ea37fb 100644
--- a/src/delay/index.ts
+++ b/src/delay/index.ts
@@ -11,27 +11,36 @@ import {
   MultiTarget,
   UnitValue,
   UnitTargetable,
+  attach,
 } from 'effector';
 
 type TimeoutType<Payload> = ((payload: Payload) => number) | Store<number> | number;
+export type DelayTimerFxProps = { payload: UnitValue<any>; milliseconds: number };
 
-export function delay<Source extends Unit<any>>(
+const timerFx = createEffect<DelayTimerFxProps, UnitValue<any>>(
+  ({ payload, milliseconds }) =>
+    new Promise((resolve) => {
+      setTimeout(resolve, milliseconds, payload);
+    }),
+)
+
+export function _delay<Source extends Unit<any>>(
   source: Source,
   timeout: TimeoutType<UnitValue<Source>>,
 ): EventAsReturnType<UnitValue<Source>>;
 
-export function delay<Source extends Unit<any>, Target extends TargetType>(config: {
+export function _delay<Source extends Unit<any>, Target extends TargetType>(config: {
   source: Source;
   timeout: TimeoutType<UnitValue<Source>>;
   target: MultiTarget<Target, UnitValue<Source>>;
 }): Target;
 
-export function delay<Source extends Unit<any>>(config: {
+export function _delay<Source extends Unit<any>>(config: {
   source: Source;
   timeout: TimeoutType<UnitValue<Source>>;
 }): EventAsReturnType<UnitValue<Source>>;
 
-export function delay<
+export function _delay<
   Source extends Unit<any>,
   Target extends TargetType = TargetType,
 >(
@@ -57,15 +66,9 @@ export function delay<
 
   const ms = validateTimeout(timeout);
 
-  const timerFx = createEffect<
-    { payload: UnitValue<Source>; milliseconds: number },
-    UnitValue<Source>
-  >(
-    ({ payload, milliseconds }) =>
-      new Promise((resolve) => {
-        setTimeout(resolve, milliseconds, payload);
-      }),
-  );
+  const innerTimerFx = attach({
+    effect: timerFx
+  });
 
   sample({
     // ms can be Store<number> | number
@@ -77,14 +80,18 @@ export function delay<
       milliseconds:
         typeof milliseconds === 'function' ? milliseconds(payload) : milliseconds,
     }),
-    target: timerFx,
+    target: innerTimerFx,
   });
 
-  sample({ clock: timerFx.doneData, target: targets as UnitTargetable<any>[] });
+  sample({ clock: innerTimerFx.doneData, target: targets as UnitTargetable<any>[] });
 
   return target as any;
 }
 
+export const delay = Object.assign(_delay, {
+  timerFx
+});
+
 function validateTimeout<T>(
   timeout: number | ((_: T) => number) | Store<number> | unknown,
 ) {
diff --git a/src/delay/readme.md b/src/delay/readme.md
index 70ac7a8d..c6f8c5dd 100644
--- a/src/delay/readme.md
+++ b/src/delay/readme.md
@@ -284,3 +284,24 @@ update('Hello');
 // after 500ms
 // => log Hello
 ```
+
+### [Tests] Exposed timers API example
+
+```ts
+const timerFx = createEffect<DelayTimerFxProps, UnitValue<any>>(
+  ({ payload, milliseconds }) =>
+    new Promise((resolve) => {
+      mySetTimeout(resolve, milliseconds, payload);
+    }),
+)
+
+const scope = fork({
+  handlers: [[delay.timerFx, timerFx]],
+});
+
+const clock = createEvent();
+const tick = delay(clock, 200);
+
+// important! call from scope
+allSettled(clock, { scope });
+```
diff --git a/src/interval/index.ts b/src/interval/index.ts
index 6460661c..c202143e 100644
--- a/src/interval/index.ts
+++ b/src/interval/index.ts
@@ -7,9 +7,42 @@ import {
   sample,
   attach,
   is,
-} from 'effector';
+  createEffect
+} from 'effector'
 
-export function interval<S extends unknown, F extends unknown>(config: {
+type SaveTimeoutEventProps = {
+  timeoutId: NodeJS.Timeout;
+  reject: () => void;
+};
+
+export type IntervalTimeoutFxProps = {
+  timeout: number;
+  running: boolean;
+  saveTimeout: EventCallable<SaveTimeoutEventProps>;
+};
+
+export type IntervalCleanupFxProps = {
+  timeoutId: NodeJS.Timeout | null;
+  rejecter: () => void;
+};
+
+const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+  if (!running) {
+    return Promise.reject();
+  }
+
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(resolve, timeout);
+    saveTimeout({ timeoutId, reject });
+  });
+})
+
+const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
+  rejecter();
+  if (timeoutId) clearTimeout(timeoutId);
+});
+
+function _interval<S extends unknown, F extends unknown>(config: {
   timeout: number | Store<number>;
   start: Event<S>;
   stop?: Event<F>;
@@ -17,13 +50,13 @@ export function interval<S extends unknown, F extends unknown>(config: {
   trailing?: boolean;
 }): { tick: Event<void>; isRunning: Store<boolean> };
 
-export function interval(config: {
+function _interval(config: {
   timeout: number | Store<number>;
   leading?: boolean;
   trailing?: boolean;
 }): TriggerProtocol;
 
-export function interval<S extends unknown, F extends unknown>({
+function _interval<S extends unknown, F extends unknown>({
   timeout,
   start,
   stop,
@@ -37,6 +70,7 @@ export function interval<S extends unknown, F extends unknown>({
   trailing?: boolean;
 }): { tick: Event<void>; isRunning: Store<boolean> } & TriggerProtocol {
   const setup = createEvent();
+
   if (start) {
     sample({
       clock: start,
@@ -45,6 +79,7 @@ export function interval<S extends unknown, F extends unknown>({
   }
 
   const teardown = createEvent();
+
   if (stop) {
     sample({
       clock: stop,
@@ -62,6 +97,7 @@ export function interval<S extends unknown, F extends unknown>({
     timeoutId: NodeJS.Timeout;
     reject: () => void;
   }>();
+
   const $timeoutId = createStore<NodeJS.Timeout | null>(null).on(
     saveTimeout,
     (_, { timeoutId }) => timeoutId,
@@ -72,33 +108,22 @@ export function interval<S extends unknown, F extends unknown>({
     (_, { reject }) => reject,
   );
 
-  const timeoutFx = attach({
+  const innerTimeoutFx = attach({
     source: { timeout: $timeout, running: $isRunning },
-    effect: ({ timeout, running }) => {
-      if (!running) {
-        return Promise.reject();
-      }
-
-      return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(resolve, timeout);
-        saveTimeout({ timeoutId, reject });
-      });
-    },
+    mapParams: (_, source) => ({ saveTimeout, ...source }),
+    effect: timeoutFx,
   });
 
-  const cleanupFx = attach({
+  const innerCleanupFx = attach({
     source: { timeoutId: $timeoutId, rejecter: $rejecter },
-    effect: ({ timeoutId, rejecter }) => {
-      rejecter();
-      if (timeoutId) clearTimeout(timeoutId);
-    },
+    effect: cleanupFx,
   });
 
   sample({
     clock: setup,
     source: $timeout,
     filter: $notRunning,
-    target: timeoutFx,
+    target: innerTimeoutFx,
   });
 
   if (leading) {
@@ -113,14 +138,14 @@ export function interval<S extends unknown, F extends unknown>({
   });
 
   sample({
-    clock: timeoutFx.done,
+    clock: innerTimeoutFx.done,
     source: $timeout,
     filter: $isRunning,
-    target: timeoutFx,
+    target: innerTimeoutFx,
   });
 
   sample({
-    clock: timeoutFx.done,
+    clock: innerTimeoutFx.done,
     filter: $isRunning,
     target: tick.prepend(() => {
       /* to be sure, nothing passed to tick */
@@ -138,7 +163,7 @@ export function interval<S extends unknown, F extends unknown>({
 
   sample({
     clock: teardown,
-    target: cleanupFx,
+    target: innerCleanupFx,
   });
 
   return {
@@ -152,6 +177,11 @@ export function interval<S extends unknown, F extends unknown>({
   };
 }
 
+export const interval = Object.assign(_interval, {
+  timeoutFx,
+  cleanupFx
+});
+
 function toStoreNumber(value: number | Store<number> | unknown): Store<number> {
   if (is.store(value)) return value;
   if (typeof value === 'number') {
diff --git a/src/interval/interval.fork.test.ts b/src/interval/interval.fork.test.ts
index 7123cd36..ea18eb20 100644
--- a/src/interval/interval.fork.test.ts
+++ b/src/interval/interval.fork.test.ts
@@ -4,10 +4,10 @@ import {
   fork,
   createStore,
   sample,
-  createWatch,
-} from 'effector';
+  createWatch, createEffect,
+} from 'effector'
 import { argumentHistory, wait, watch } from '../../test-library';
-import { interval } from '.';
+import { interval, IntervalCleanupFxProps, IntervalTimeoutFxProps } from '.'
 
 test('works in forked scope', async () => {
   const start = createEvent();
@@ -130,3 +130,50 @@ describe('@@trigger', () => {
     unwatch();
   });
 });
+
+test('exposed timers api', async () => {
+  const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+    if (!running) {
+      return Promise.reject();
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, timeout / 2);
+      saveTimeout({ timeoutId, reject });
+    });
+  })
+
+  const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
+    rejecter();
+    if (timeoutId) clearTimeout(timeoutId);
+  });
+
+  const scope = fork({
+    handlers: [
+      [interval.timeoutFx, timeoutFx],
+      [interval.cleanupFx, cleanupFx]
+    ],
+  });
+
+  const start = createEvent();
+  const stop = createEvent();
+
+  const { tick } = interval({ start, stop, timeout: 50 });
+
+  const mockedFn = jest.fn();
+  createWatch({
+    unit: tick,
+    fn: mockedFn,
+    scope,
+  });
+
+  allSettled(start, { scope });
+
+  await wait(20);
+
+  expect(mockedFn).not.toBeCalled();
+
+  await wait(5);
+
+  expect(mockedFn).toBeCalled();
+});
diff --git a/src/interval/readme.md b/src/interval/readme.md
index d5ea42c4..31871539 100644
--- a/src/interval/readme.md
+++ b/src/interval/readme.md
@@ -102,3 +102,38 @@ keepFresh(someQuery, {
   triggers: [interval({ timeout: 1000 })],
 });
 ```
+
+### [Tests] Exposed timers API example
+
+```ts
+const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+  if (!running) {
+    return Promise.reject();
+  }
+
+  return new Promise((resolve, reject) => {
+    const timeoutId = mySetTimeout(resolve, timeout);
+    saveTimeout({ timeoutId, reject });
+  });
+})
+
+const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
+  rejecter();
+  if (timeoutId) myClearTimeout(timeoutId);
+});
+
+const scope = fork({
+  handlers: [
+    [interval.timeoutFx, timeoutFx],
+    [interval.cleanupFx, cleanupFx]
+  ],
+});
+
+const start = createEvent();
+const stop = createEvent();
+
+const { tick } = interval({ start, stop, timeout: 1000 });
+
+// important! call from scope
+allSettled(start, { scope });
+```
diff --git a/src/throttle/index.ts b/src/throttle/index.ts
index 042189b8..31f2263a 100644
--- a/src/throttle/index.ts
+++ b/src/throttle/index.ts
@@ -1,4 +1,5 @@
 import {
+  attach,
   createEffect,
   createEvent,
   createStore,
@@ -8,26 +9,30 @@ import {
   Store,
   Unit,
   UnitTargetable,
-} from 'effector';
+} from 'effector'
 
 type EventAsReturnType<Payload> = any extends Payload ? Event<Payload> : never;
 
-export function throttle<T>(
+const timerFx = createEffect<number, void>({
+  handler: (timeout) => new Promise((resolve) => setTimeout(resolve, timeout)),
+});
+
+export function _throttle<T>(
   source: Unit<T>,
   timeout: number | Store<number>,
 ): EventAsReturnType<T>;
-export function throttle<T>(_: {
+export function _throttle<T>(_: {
   source: Unit<T>;
   timeout: number | Store<number>;
   name?: string;
 }): EventAsReturnType<T>;
-export function throttle<T, Target extends UnitTargetable<T>>(_: {
+export function _throttle<T, Target extends UnitTargetable<T>>(_: {
   source: Unit<T>;
   timeout: number | Store<number>;
   target: Target;
   name?: string;
 }): Target;
-export function throttle<T>(
+export function _throttle<T>(
   ...args:
     | [
         {
@@ -46,9 +51,10 @@ export function throttle<T>(
 
   const $timeout = toStoreNumber(timeout);
 
-  const timerFx = createEffect<number, void>({
+  const innerTimerFx = attach({
     name: `throttle(${(source as Event<T>).shortName || source.kind}) effect`,
-    handler: (timeout) => new Promise((resolve) => setTimeout(resolve, timeout)),
+    mapParams: (params: number) => params,
+    effect: timerFx,
   });
 
   // It's ok - nothing will ever start unless source is triggered
@@ -72,18 +78,22 @@ export function throttle<T>(
   sample({
     source: $timeout,
     clock: triggerTick as Unit<any>,
-    target: timerFx,
+    target: innerTimerFx,
   });
 
   sample({
     source: $payload,
-    clock: timerFx.done,
+    clock: innerTimerFx.done,
     target,
   });
 
   return target as any;
 }
 
+export const throttle = Object.assign(_throttle, {
+  timerFx,
+});
+
 function toStoreNumber(value: number | Store<number> | unknown): Store<number> {
   if (is.store(value)) return value;
   if (typeof value === 'number') {
diff --git a/src/throttle/readme.md b/src/throttle/readme.md
index 3211ae77..d2840d99 100644
--- a/src/throttle/readme.md
+++ b/src/throttle/readme.md
@@ -242,6 +242,24 @@ const throttledStore: Event<number> = throttle({
 });
 ```
 
+### [Tests] Exposed timers API example
+
+```ts
+const timerFx = createEffect<number, void>({
+  handler: (timeout) => new Promise((resolve) => setTimeout(resolve, timeout)),
+});
+
+const scope = fork({
+  handlers: [[throttle.timerFx, timerFx]],
+});
+
+const clock = createEvent();
+const tick = throttle(clock, 200);
+
+// important! call from scope
+allSettled(clock, { scope });
+```
+
 [_`event`_]: https://effector.dev/docs/api/effector/event
 [_`effect`_]: https://effector.dev/docs/api/effector/effect
 [_`store`_]: https://effector.dev/docs/api/effector/store
diff --git a/src/throttle/throttle.fork.test.ts b/src/throttle/throttle.fork.test.ts
index 7d43bcc6..d78639c3 100644
--- a/src/throttle/throttle.fork.test.ts
+++ b/src/throttle/throttle.fork.test.ts
@@ -6,8 +6,8 @@ import {
   allSettled,
   createEvent,
   createStore,
-  sample,
-} from 'effector';
+  sample, createEffect, createWatch,
+} from 'effector'
 
 import { throttle } from './index';
 import { wait } from '../../test-library';
@@ -157,3 +157,35 @@ describe('edge cases', () => {
     expect(listener).toBeCalledWith('two');
   });
 })
+
+test('exposed timers api', async () => {
+  const timerFx = createEffect<number, void>({
+    handler: (timeout) => new Promise((resolve) => setTimeout(resolve, timeout / 2)),
+  });
+
+  const scope = fork({
+    handlers: [[throttle.timerFx, timerFx]],
+  });
+
+  const clock = createEvent();
+  const tick = throttle(clock, 50);
+
+  const mockedFn = jest.fn();
+
+  createWatch({
+    unit: tick,
+    fn: mockedFn,
+    scope,
+  });
+
+  allSettled(clock, { scope });
+
+
+  await wait(20);
+
+  expect(mockedFn).not.toBeCalled();
+
+  await wait(5);
+
+  expect(mockedFn).toBeCalled();
+})
diff --git a/src/time/index.ts b/src/time/index.ts
index d0291189..4e5e5be7 100644
--- a/src/time/index.ts
+++ b/src/time/index.ts
@@ -1,16 +1,26 @@
-import { createEffect, Unit, restore, sample, Store, is } from 'effector';
+import {
+  createEffect,
+  Unit,
+  restore,
+  sample,
+  Store,
+  is,
+  attach, Effect
+} from 'effector'
 
 const defaultNow = <Time = number>() => Date.now() as unknown as Time;
 
 type NoInfer<T> = [T][T extends any ? 0 : never];
 
-export function time(clock: Unit<any>): Store<number>;
-export function time<Time = number>(config: {
+const readNowFx = createEffect<{ timeReader: () => number }, number>(({ timeReader }) => timeReader());
+
+export function _time(clock: Unit<any>): Store<number>;
+export function _time<Time = number>(config: {
   clock: Unit<any>;
   getNow?: () => Time;
   initial?: NoInfer<Time>;
 }): Store<Time>;
-export function time<Time = number>(
+export function _time<Time = number>(
   args:
     | {
         clock: Unit<any>;
@@ -22,8 +32,15 @@ export function time<Time = number>(
   const argsShape = is.unit(args) ? { clock: args } : args;
   const { clock, getNow, initial } = argsShape;
   const timeReader = getNow ?? defaultNow;
-  const readNowFx = createEffect<void, Time>(timeReader);
-  const $time = restore(readNowFx, initial ?? timeReader());
-  sample({ clock, target: readNowFx });
+  const innerReadNowFx = attach({
+    mapParams: () => ({ timeReader }),
+    effect: readNowFx as unknown as Effect<{ timeReader: () => Time }, Time>
+  });
+  const $time = restore(innerReadNowFx, initial ?? timeReader());
+  sample({ clock, target: innerReadNowFx });
   return $time;
 }
+
+export const time = Object.assign(_time, {
+  readNowFx
+});
diff --git a/src/time/readme.md b/src/time/readme.md
index e54be12f..2f7bd1ab 100644
--- a/src/time/readme.md
+++ b/src/time/readme.md
@@ -110,3 +110,20 @@ tick();
 ```
 
 [Try it](https://share.effector.dev/VuhhzWKE)
+
+### [Tests] Exposed timers API example
+
+```ts
+// you can attach() any source of time
+const readNowFx = createEffect<{ timeReader: () => number }, number>(({ timeReader }) => timeReader());
+
+const scope = fork({
+  handlers: [[time.readNowFx, readNowFx]],
+});
+
+const clock = createEvent();
+const $time = time(clock);
+
+// important! call from scope
+allSettled(clock, { scope });
+```
diff --git a/src/time/time.fork.test.ts b/src/time/time.fork.test.ts
index a6aea1fe..922bbef6 100644
--- a/src/time/time.fork.test.ts
+++ b/src/time/time.fork.test.ts
@@ -1,5 +1,11 @@
 import 'regenerator-runtime/runtime';
-import { createEvent, fork, serialize, allSettled } from 'effector';
+import {
+  createEvent,
+  fork,
+  serialize,
+  allSettled,
+  createEffect
+} from 'effector'
 
 import { time } from './index';
 
@@ -51,3 +57,26 @@ test('store must correctly serializes', async () => {
     }
   `);
 });
+
+test('exposed timers api', async () => {
+  let now = 10000;
+
+  const readNowFx = createEffect<void, number>(() => now);
+
+  const scope = fork({
+    handlers: [[time.readNowFx, readNowFx]],
+  });
+
+  const clock = createEvent();
+  const $time = time(clock);
+
+  await allSettled(clock, { scope });
+
+  expect(scope.getState($time)).toBe(10000);
+
+  now = 20000;
+
+  await allSettled(clock, { scope });
+
+  expect(scope.getState($time)).toBe(20000);
+});
diff --git a/src/time/time.test.ts b/src/time/time.test.ts
index bf781ae9..33f30fe6 100644
--- a/src/time/time.test.ts
+++ b/src/time/time.test.ts
@@ -110,6 +110,7 @@ test('any changes of $time store from outerworld should be overriden on clock',
   const force = createEvent();
   let counter = 0;
   const $time = time({ clock, getNow: () => ++counter });
+  // @ts-expect-error
   sample({ clock: force, fn: () => 1000, target: $time });
   expect($time.getState()).toBe(1);
 

From cf55ce77b4c5f18dede807c83ba2bf7eb12971de Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Tue, 23 Apr 2024 15:57:38 +0300
Subject: [PATCH 2/6] fix: add scopeBind for events

---
 src/debounce/debounce.fork.test.ts | 16 +++++++++++-----
 src/debounce/index.ts              |  8 ++++++--
 src/debounce/readme.md             |  6 ++++--
 src/interval/index.ts              |  6 ++++--
 src/interval/interval.fork.test.ts |  6 ++++--
 src/interval/readme.md             |  6 ++++--
 6 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/src/debounce/debounce.fork.test.ts b/src/debounce/debounce.fork.test.ts
index 8de77172..84df780c 100644
--- a/src/debounce/debounce.fork.test.ts
+++ b/src/debounce/debounce.fork.test.ts
@@ -7,7 +7,7 @@ import {
   createEvent,
   createStore,
   sample,
-  createWatch, createEffect,
+  createWatch, createEffect, scopeBind,
 } from 'effector'
 import { wait, watch } from '../../test-library';
 
@@ -186,10 +186,16 @@ describe('edge cases', () => {
   test('does not call target twice for sample chain doubles', async () => {
     const trigger = createEvent();
 
+    const scope = fork();
     const db = debounce({ source: trigger, timeout: 100 });
 
     const listener = jest.fn();
-    db.watch(listener);
+
+    createWatch({
+      unit: db,
+      fn: listener,
+      scope,
+    })
 
     const start = createEvent();
     const secondTrigger = createEvent();
@@ -197,8 +203,6 @@ describe('edge cases', () => {
     sample({ clock: start, fn: () => 'one', target: [secondTrigger, trigger] });
     sample({ clock: secondTrigger, fn: () => 'two', target: [trigger] });
 
-    const scope = fork();
-
     await allSettled(start, { scope });
 
     expect(listener).toBeCalledTimes(1);
@@ -235,10 +239,12 @@ describe('edge cases', () => {
 
 test('exposed timers api', async () => {
   const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
+    const save = scopeBind(saveCancel);
+
     if (timeoutId) clearTimeout(timeoutId);
     if (rejectPromise) rejectPromise();
     return new Promise((resolve, reject) => {
-      saveCancel([setTimeout(resolve, timeout / 2), reject]);
+      save([setTimeout(resolve, timeout / 2), reject]);
     });
   });
 
diff --git a/src/debounce/index.ts b/src/debounce/index.ts
index d52d0981..14f2d61c 100644
--- a/src/debounce/index.ts
+++ b/src/debounce/index.ts
@@ -9,8 +9,9 @@ import {
   merge,
   UnitTargetable,
   EventAsReturnType,
-  createEffect, EventCallable
+  createEffect, EventCallable, scopeBind
 } from 'effector'
+import { debug } from '../debug'
 
 export type DebounceTimerFxProps = {
   timeoutId?: NodeJS.Timeout;
@@ -20,10 +21,12 @@ export type DebounceTimerFxProps = {
 };
 
 const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
+  const save = scopeBind(saveCancel);
+
   if (timeoutId) clearTimeout(timeoutId);
   if (rejectPromise) rejectPromise();
   return new Promise((resolve, reject) => {
-    saveCancel([setTimeout(resolve, timeout), reject]);
+    save([setTimeout(resolve, timeout), reject]);
   });
 });
 
@@ -72,6 +75,7 @@ export function _debounce<T>(
   }).on(saveCancel, (_, payload) => payload);
 
   const tick = (target as UnitTargetable<T>) ?? createEvent();
+  debug($canceller)
 
   const innerTimerFx = attach({
     name: name || `debounce(${(source as any)?.shortName || source.kind}) effect`,
diff --git a/src/debounce/readme.md b/src/debounce/readme.md
index e4bfd6a1..3461a702 100644
--- a/src/debounce/readme.md
+++ b/src/debounce/readme.md
@@ -202,10 +202,12 @@ someHappened(4);
 
 ```ts
 const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
-  if (timeoutId) myClearTimeout(timeoutId);
+  const save = scopeBind(saveCancel);
+
+  if (timeoutId) clearTimeout(timeoutId);
   if (rejectPromise) rejectPromise();
   return new Promise((resolve, reject) => {
-    saveCancel([mySetTimeout(resolve, timeout), reject]);
+    save([setTimeout(resolve, timeout), reject]);
   });
 });
 
diff --git a/src/interval/index.ts b/src/interval/index.ts
index c202143e..6c875445 100644
--- a/src/interval/index.ts
+++ b/src/interval/index.ts
@@ -7,7 +7,7 @@ import {
   sample,
   attach,
   is,
-  createEffect
+  createEffect, scopeBind
 } from 'effector'
 
 type SaveTimeoutEventProps = {
@@ -27,13 +27,15 @@ export type IntervalCleanupFxProps = {
 };
 
 const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+  const save = scopeBind(saveTimeout);
+
   if (!running) {
     return Promise.reject();
   }
 
   return new Promise((resolve, reject) => {
     const timeoutId = setTimeout(resolve, timeout);
-    saveTimeout({ timeoutId, reject });
+    save({ timeoutId, reject });
   });
 })
 
diff --git a/src/interval/interval.fork.test.ts b/src/interval/interval.fork.test.ts
index ea18eb20..f0dba77c 100644
--- a/src/interval/interval.fork.test.ts
+++ b/src/interval/interval.fork.test.ts
@@ -4,7 +4,7 @@ import {
   fork,
   createStore,
   sample,
-  createWatch, createEffect,
+  createWatch, createEffect, scopeBind,
 } from 'effector'
 import { argumentHistory, wait, watch } from '../../test-library';
 import { interval, IntervalCleanupFxProps, IntervalTimeoutFxProps } from '.'
@@ -133,13 +133,15 @@ describe('@@trigger', () => {
 
 test('exposed timers api', async () => {
   const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+    const save = scopeBind(saveTimeout);
+
     if (!running) {
       return Promise.reject();
     }
 
     return new Promise((resolve, reject) => {
       const timeoutId = setTimeout(resolve, timeout / 2);
-      saveTimeout({ timeoutId, reject });
+      save({ timeoutId, reject });
     });
   })
 
diff --git a/src/interval/readme.md b/src/interval/readme.md
index 31871539..f3d78321 100644
--- a/src/interval/readme.md
+++ b/src/interval/readme.md
@@ -107,13 +107,15 @@ keepFresh(someQuery, {
 
 ```ts
 const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
+  const save = scopeBind(saveTimeout);
+
   if (!running) {
     return Promise.reject();
   }
 
   return new Promise((resolve, reject) => {
-    const timeoutId = mySetTimeout(resolve, timeout);
-    saveTimeout({ timeoutId, reject });
+    const timeoutId = setTimeout(resolve, timeout);
+    save({ timeoutId, reject });
   });
 })
 

From 778c8b22bcb453121ec614e7f00a8619b751f53e Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Tue, 23 Apr 2024 19:07:56 +0300
Subject: [PATCH 3/6] fix: interval & debounce & time

---
 src/debounce/debounce.fork.test.ts | 10 +++--
 src/debounce/index.ts              | 41 ++++++++++----------
 src/debounce/readme.md             |  8 ++--
 src/interval/index.ts              | 60 +++++++++++-------------------
 src/interval/interval.fork.test.ts | 12 +++---
 src/interval/readme.md             | 14 +++----
 src/time/time.fork.test.ts         |  4 +-
 7 files changed, 66 insertions(+), 83 deletions(-)

diff --git a/src/debounce/debounce.fork.test.ts b/src/debounce/debounce.fork.test.ts
index 84df780c..6b6d737e 100644
--- a/src/debounce/debounce.fork.test.ts
+++ b/src/debounce/debounce.fork.test.ts
@@ -7,7 +7,7 @@ import {
   createEvent,
   createStore,
   sample,
-  createWatch, createEffect, scopeBind,
+  createWatch, createEffect,
 } from 'effector'
 import { wait, watch } from '../../test-library';
 
@@ -238,13 +238,15 @@ describe('edge cases', () => {
 });
 
 test('exposed timers api', async () => {
-  const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
-    const save = scopeBind(saveCancel);
+  const timerFx = createEffect(({ canceller, timeout }: DebounceTimerFxProps) => {
+    const { timeoutId, rejectPromise } = canceller;
 
     if (timeoutId) clearTimeout(timeoutId);
     if (rejectPromise) rejectPromise();
+
     return new Promise((resolve, reject) => {
-      save([setTimeout(resolve, timeout / 2), reject]);
+      canceller.timeoutId = setTimeout(resolve, timeout / 2);
+      canceller.rejectPromise = reject;
     });
   });
 
diff --git a/src/debounce/index.ts b/src/debounce/index.ts
index 14f2d61c..6d97d504 100644
--- a/src/debounce/index.ts
+++ b/src/debounce/index.ts
@@ -9,24 +9,26 @@ import {
   merge,
   UnitTargetable,
   EventAsReturnType,
-  createEffect, EventCallable, scopeBind
+  createEffect
 } from 'effector'
-import { debug } from '../debug'
+import { spread } from '../spread'
+
+type DebounceCanceller = { timeoutId?: NodeJS.Timeout; rejectPromise?: () => void; };
 
 export type DebounceTimerFxProps = {
-  timeoutId?: NodeJS.Timeout;
-  rejectPromise?: () => void;
-  saveCancel: EventCallable<[NodeJS.Timeout, () => void]>;
+  canceller: DebounceCanceller;
   timeout: number;
 };
 
-const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
-  const save = scopeBind(saveCancel);
+const timerFx = createEffect(({ canceller, timeout }: DebounceTimerFxProps) => {
+  const { timeoutId, rejectPromise } = canceller;
 
   if (timeoutId) clearTimeout(timeoutId);
   if (rejectPromise) rejectPromise();
+
   return new Promise((resolve, reject) => {
-    save([setTimeout(resolve, timeout), reject]);
+    canceller.timeoutId = setTimeout(resolve, timeout);
+    canceller.rejectPromise = reject;
   });
 });
 
@@ -69,23 +71,16 @@ export function _debounce<T>(
 
   const $timeout = toStoreNumber(timeout);
 
-  const saveCancel = createEvent<[NodeJS.Timeout, () => void]>();
-  const $canceller = createStore<[NodeJS.Timeout, () => void] | []>([], {
+  const $canceller = createStore<DebounceCanceller | null>(null, {
     serialize: 'ignore',
-  }).on(saveCancel, (_, payload) => payload);
+  });
 
   const tick = (target as UnitTargetable<T>) ?? createEvent();
-  debug($canceller)
 
   const innerTimerFx = attach({
     name: name || `debounce(${(source as any)?.shortName || source.kind}) effect`,
-    source: $canceller,
-    mapParams: (timeout: number, [timeoutId, rejectPromise]) => ({
-      timeout,
-      timeoutId,
-      rejectPromise,
-      saveCancel
-    }),
+    source: $canceller as Store<DebounceCanceller>,
+    mapParams: (timeout: number, source: DebounceCanceller) => ({ canceller: source, timeout }),
     effect: timerFx,
   });
 
@@ -127,9 +122,13 @@ export function _debounce<T>(
   });
 
   sample({
-    source: $timeout,
+    source: { timeout: $timeout, canceller: $canceller },
     clock: triggerTick,
-    target: innerTimerFx,
+    fn: ({ timeout, canceller }) => ({ timeout, canceller: canceller ?? {} }),
+    target: spread({
+      timeout: innerTimerFx,
+      canceller: $canceller
+    }),
   });
 
   sample({
diff --git a/src/debounce/readme.md b/src/debounce/readme.md
index 3461a702..f7253b4e 100644
--- a/src/debounce/readme.md
+++ b/src/debounce/readme.md
@@ -201,13 +201,15 @@ someHappened(4);
 ### [Tests] Exposed timers API example
 
 ```ts
-const timerFx = createEffect(({ timeoutId, rejectPromise, saveCancel, timeout }: DebounceTimerFxProps) => {
-  const save = scopeBind(saveCancel);
+const timerFx = createEffect(({ canceller, timeout }: DebounceTimerFxProps) => {
+  const { timeoutId, rejectPromise } = canceller;
 
   if (timeoutId) clearTimeout(timeoutId);
   if (rejectPromise) rejectPromise();
+
   return new Promise((resolve, reject) => {
-    save([setTimeout(resolve, timeout), reject]);
+    canceller.timeoutId = setTimeout(resolve, timeout);
+    canceller.rejectPromise = reject;
   });
 });
 
diff --git a/src/interval/index.ts b/src/interval/index.ts
index 6c875445..6fd6be4c 100644
--- a/src/interval/index.ts
+++ b/src/interval/index.ts
@@ -1,46 +1,41 @@
 import {
-  Event,
-  EventCallable,
-  Store,
+  attach,
+  createEffect,
   createEvent,
   createStore,
-  sample,
-  attach,
+  Event,
+  EventCallable,
   is,
-  createEffect, scopeBind
+  sample,
+  Store
 } from 'effector'
 
-type SaveTimeoutEventProps = {
+type IntervalCanceller = {
   timeoutId: NodeJS.Timeout;
   reject: () => void;
 };
 
 export type IntervalTimeoutFxProps = {
+  canceller: IntervalCanceller;
   timeout: number;
   running: boolean;
-  saveTimeout: EventCallable<SaveTimeoutEventProps>;
 };
 
-export type IntervalCleanupFxProps = {
-  timeoutId: NodeJS.Timeout | null;
-  rejecter: () => void;
-};
-
-const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
-  const save = scopeBind(saveTimeout);
+export type IntervalCleanupFxProps = IntervalCanceller;
 
+const timeoutFx = createEffect(({ canceller, timeout, running }: IntervalTimeoutFxProps) => {
   if (!running) {
     return Promise.reject();
   }
 
   return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(resolve, timeout);
-    save({ timeoutId, reject });
+    canceller.timeoutId = setTimeout(resolve, timeout);
+    canceller.reject = reject;
   });
 })
 
-const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
-  rejecter();
+const cleanupFx = createEffect(({ reject, timeoutId }: IntervalCleanupFxProps) => {
+  reject();
   if (timeoutId) clearTimeout(timeoutId);
 });
 
@@ -95,37 +90,26 @@ function _interval<S extends unknown, F extends unknown>({
 
   const $notRunning = $isRunning.map((running) => !running, { skipVoid: false });
 
-  const saveTimeout = createEvent<{
-    timeoutId: NodeJS.Timeout;
-    reject: () => void;
-  }>();
-
-  const $timeoutId = createStore<NodeJS.Timeout | null>(null).on(
-    saveTimeout,
-    (_, { timeoutId }) => timeoutId,
-  );
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  const $rejecter = createStore<() => void>(() => {}).on(
-    saveTimeout,
-    (_, { reject }) => reject,
-  );
+  const $canceller = createStore<IntervalCanceller | null>(null);
 
   const innerTimeoutFx = attach({
-    source: { timeout: $timeout, running: $isRunning },
-    mapParams: (_, source) => ({ saveTimeout, ...source }),
+    source: { canceller: $canceller as Store<IntervalCanceller>, running: $isRunning, timeout: $timeout },
+    mapParams: (_, source) => source,
     effect: timeoutFx,
   });
 
   const innerCleanupFx = attach({
-    source: { timeoutId: $timeoutId, rejecter: $rejecter },
+    source: $canceller as Store<IntervalCanceller>,
+    mapParams: (_, source) => source,
     effect: cleanupFx,
   });
 
   sample({
     clock: setup,
-    source: $timeout,
+    source: $canceller,
     filter: $notRunning,
-    target: innerTimeoutFx,
+    fn: (canceller) => canceller ?? {},
+    target: [innerTimeoutFx, $canceller],
   });
 
   if (leading) {
diff --git a/src/interval/interval.fork.test.ts b/src/interval/interval.fork.test.ts
index f0dba77c..f6742411 100644
--- a/src/interval/interval.fork.test.ts
+++ b/src/interval/interval.fork.test.ts
@@ -132,21 +132,19 @@ describe('@@trigger', () => {
 });
 
 test('exposed timers api', async () => {
-  const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
-    const save = scopeBind(saveTimeout);
-
+  const timeoutFx = createEffect(({ canceller, timeout, running }: IntervalTimeoutFxProps) => {
     if (!running) {
       return Promise.reject();
     }
 
     return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(resolve, timeout / 2);
-      save({ timeoutId, reject });
+      canceller.timeoutId = setTimeout(resolve, timeout / 2);
+      canceller.reject = reject;
     });
   })
 
-  const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
-    rejecter();
+  const cleanupFx = createEffect(({ reject, timeoutId }: IntervalCleanupFxProps) => {
+    reject();
     if (timeoutId) clearTimeout(timeoutId);
   });
 
diff --git a/src/interval/readme.md b/src/interval/readme.md
index f3d78321..d59e066c 100644
--- a/src/interval/readme.md
+++ b/src/interval/readme.md
@@ -106,22 +106,20 @@ keepFresh(someQuery, {
 ### [Tests] Exposed timers API example
 
 ```ts
-const timeoutFx = createEffect(({ timeout, running, saveTimeout }: IntervalTimeoutFxProps) => {
-  const save = scopeBind(saveTimeout);
-
+const timeoutFx = createEffect(({ canceller, timeout, running }: IntervalTimeoutFxProps) => {
   if (!running) {
     return Promise.reject();
   }
 
   return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(resolve, timeout);
-    save({ timeoutId, reject });
+    canceller.timeoutId = setTimeout(resolve, timeout);
+    canceller.reject = reject;
   });
 })
 
-const cleanupFx = createEffect(({ rejecter, timeoutId }: IntervalCleanupFxProps) => {
-  rejecter();
-  if (timeoutId) myClearTimeout(timeoutId);
+const cleanupFx = createEffect(({ reject, timeoutId }: IntervalCleanupFxProps) => {
+  reject();
+  if (timeoutId) clearTimeout(timeoutId);
 });
 
 const scope = fork({
diff --git a/src/time/time.fork.test.ts b/src/time/time.fork.test.ts
index 922bbef6..7f86c653 100644
--- a/src/time/time.fork.test.ts
+++ b/src/time/time.fork.test.ts
@@ -48,12 +48,12 @@ test('store must correctly serializes', async () => {
   await allSettled(clock, { scope: scopeB });
   expect(serialize(scopeA)).toMatchInlineSnapshot(`
     {
-      "-9m03zk|-k3vl4d": 2,
+      "-6rqdme|-40cfpr": 2,
     }
   `);
   expect(serialize(scopeB)).toMatchInlineSnapshot(`
     {
-      "-9m03zk|-k3vl4d": 3,
+      "-6rqdme|-40cfpr": 3,
     }
   `);
 });

From c1ec0e55f4e422e60d6443f0a4e7f3994bc29afe Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Tue, 23 Apr 2024 19:18:10 +0300
Subject: [PATCH 4/6] fix: remove spread

---
 src/debounce/index.ts | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/debounce/index.ts b/src/debounce/index.ts
index 6d97d504..8aa29e8d 100644
--- a/src/debounce/index.ts
+++ b/src/debounce/index.ts
@@ -10,8 +10,7 @@ import {
   UnitTargetable,
   EventAsReturnType,
   createEffect
-} from 'effector'
-import { spread } from '../spread'
+} from 'effector';
 
 type DebounceCanceller = { timeoutId?: NodeJS.Timeout; rejectPromise?: () => void; };
 
@@ -122,13 +121,17 @@ export function _debounce<T>(
   });
 
   sample({
-    source: { timeout: $timeout, canceller: $canceller },
     clock: triggerTick,
-    fn: ({ timeout, canceller }) => ({ timeout, canceller: canceller ?? {} }),
-    target: spread({
-      timeout: innerTimerFx,
-      canceller: $canceller
-    }),
+    source: $timeout,
+    fn: (timeout) => timeout,
+    target: innerTimerFx,
+  });
+
+  sample({
+    clock: triggerTick,
+    source: $canceller,
+    fn: (canceller) => canceller ?? {},
+    target: $canceller,
   });
 
   sample({

From 51ed264ca62c0b1d0cc392585576b503395a5065 Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Tue, 23 Apr 2024 19:38:16 +0300
Subject: [PATCH 5/6] docs: update for debounce & interval & time

---
 src/debounce/readme.md | 3 +++
 src/interval/readme.md | 3 +++
 src/time/readme.md     | 6 +++++-
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/debounce/readme.md b/src/debounce/readme.md
index f7253b4e..bf6a7504 100644
--- a/src/debounce/readme.md
+++ b/src/debounce/readme.md
@@ -201,6 +201,9 @@ someHappened(4);
 ### [Tests] Exposed timers API example
 
 ```ts
+/**
+ * `canceller` - is object, which contains previous timeout id and previous effect promise reject
+ */
 const timerFx = createEffect(({ canceller, timeout }: DebounceTimerFxProps) => {
   const { timeoutId, rejectPromise } = canceller;
 
diff --git a/src/interval/readme.md b/src/interval/readme.md
index d59e066c..bf0507e9 100644
--- a/src/interval/readme.md
+++ b/src/interval/readme.md
@@ -106,6 +106,9 @@ keepFresh(someQuery, {
 ### [Tests] Exposed timers API example
 
 ```ts
+/**
+ * `canceller` - is object, which contains previous timeout id and previous effect promise reject
+ */
 const timeoutFx = createEffect(({ canceller, timeout, running }: IntervalTimeoutFxProps) => {
   if (!running) {
     return Promise.reject();
diff --git a/src/time/readme.md b/src/time/readme.md
index 2f7bd1ab..7ee86e28 100644
--- a/src/time/readme.md
+++ b/src/time/readme.md
@@ -114,7 +114,11 @@ tick();
 ### [Tests] Exposed timers API example
 
 ```ts
-// you can attach() any source of time
+/**
+ * `timeReader` - is a either `Date.now` or the handler, that was provided via `getNow` in the configuration
+ *
+ * In your custom `readNowFx` you can change the way original time reader is used or call your own timer instead
+ */
 const readNowFx = createEffect<{ timeReader: () => number }, number>(({ timeReader }) => timeReader());
 
 const scope = fork({

From 2dbde5a7450a9a3a5d0d437287112ba40971eae1 Mon Sep 17 00:00:00 2001
From: Edward Gigolaev <49155506+movpushmov@users.noreply.github.com>
Date: Wed, 8 May 2024 22:18:06 +0300
Subject: [PATCH 6/6] fix: open handler in interval test

---
 src/interval/interval.fork.test.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/interval/interval.fork.test.ts b/src/interval/interval.fork.test.ts
index f6742411..7f34220d 100644
--- a/src/interval/interval.fork.test.ts
+++ b/src/interval/interval.fork.test.ts
@@ -176,4 +176,6 @@ test('exposed timers api', async () => {
   await wait(5);
 
   expect(mockedFn).toBeCalled();
+
+  stop();
 });