Allow clock in reset to be optional (#272)

Co-authored-by: Sova <[email protected]>
Co-authored-by: Viktor <[email protected]>

src/reset/index.ts

@@ -1,15 +1,21 @@
-import { Unit, Store } from 'effector';
+import { createEvent } from 'effector';
 
-export function reset({
-  clock,
-  target,
-}: {
-  clock: Unit<any> | Array<Unit<any>>;
+import type { Event, Unit, Store } from 'effector';
+
+type Params = {
+  clock?: Unit<any> | Array<Unit<any>>;
   target: Store<any> | Array<Store<any>>;
-}): void {
+};
+
+export function reset(config: Required<Params>): void;
+export function reset(config: Pick<Params, 'target'>): Event<void>;
+
+export function reset({ clock, target }: Params) {
   const targets = Array.isArray(target) ? target : [target];
-  const clocks = Array.isArray(clock) ? clock : [clock];
+  const clocks = Array.isArray(clock) ? clock : [clock ?? createEvent()];
   targets.forEach((target) => {
     target.reset(clocks);
   });
+
+  return clock === undefined ? clocks[0] : undefined;
 }

src/reset/readme.md

@@ -10,7 +10,7 @@ import { reset } from 'patronum';
 import { reset } from 'patronum/reset';
 ```
 
-````
+## `reset({ clock, target })`
 
 ### Motivation
 
@@ -20,7 +20,7 @@ The method allow to reset many stores by a single line
 
 ```ts
 reset({ clock, target });
-````
+```
 
 - When `clock` is triggered, reset store/stores in `target` to the initial value.
 
@@ -48,6 +48,17 @@ reset({
 });
 ```
 
+```ts
+import { createStore } from 'effector';
+import { reset } from 'patronum/reset';
+
+const $post = createStore(null);
+const $comments = createStore([]);
+const $draftComment = createStore('');
+
+const resetEvent = reset({ target: [$post, $comments, $draftComment] });
+```
+
 [Try it](https://share.effector.dev/06hpVftG)
 
 ### Alternative
@@ -74,3 +85,62 @@ resetOnSomeCases.onCreateStore((store) => {
   store.reset([pageUnmounted, userSessionFinished]);
 });
 ```
+
+## `reset({ target })`
+
+### Motivation
+
+The method allow to reset many stores by a single line with no `clock` passing
+
+:::note since
+The `clock` argument became optional since patronum 1.15.0
+:::
+
+### Formulae
+
+```ts
+const resetEvent = reset({ target });
+```
+
+- When `resetEvent` is triggered, reset store/stores in `target` to the initial value.
+
+### Arguments
+
+1. `target: Store<any> | Array<Store<any>>` — Each of these stores will be reset to the initial values when `resetEvent` is triggered.
+
+### Returns
+
+- `resetEvent` `(Event<void>)` — New event that reset store/stores in `target`.
+
+### Example
+
+```ts
+import { createEvent, createStore } from 'effector';
+import { reset } from 'patronum/reset';
+
+const $post = createStore(null);
+const $comments = createStore([]);
+const $draftComment = createStore('');
+
+const resetEvent = reset({ target: [$post, $comments, $draftComment] });
+```
+
+### Alternative
+
+Write reset event by yourself:
+
+```ts
+import { createEvent, createStore } from 'effector';
+import { reset } from 'patronum/reset';
+
+const $post = createStore(null);
+const $comments = createStore([]);
+const $draftComment = createStore('');
+
+const resetEvent = createEvent();
+
+reset({
+  clock: resetEvent,
+  target: [$post, $comments, $draftComment],
+});
+```

src/reset/reset.fork.test.ts

@@ -57,3 +57,16 @@ test('do not affects original store state', async () => {
   expect(scope.getState($source)).toEqual(0);
   expect($source.getState()).toEqual(0);
 });
+
+test('works in forked scope without passed clock', async () => {
+  const setSource = createEvent<number>();
+  const $source = restore(setSource, 0);
+  const resetEvent = reset({ target: $source });
+
+  const scope = fork();
+  await allSettled(setSource, { scope, params: 100 });
+  expect(scope.getState($source)).toEqual(100);
+
+  await allSettled(resetEvent, { scope });
+  expect(scope.getState($source)).toEqual(0);
+});

src/reset/reset.test.ts

@@ -88,3 +88,17 @@ describe('multiple targets', () => {
     expect([$sourceA.getState(), $sourceB.getState()]).toEqual([0, '0']);
   });
 });
+
+describe('without clock in params', () => {
+  test('should return reset event', () => {
+    const setValue = createEvent<number>();
+    const $source = restore(setValue, 0);
+    const resetEvent = reset({ target: $source });
+
+    setValue(100);
+    expect($source.getState()).toEqual(100);
+
+    resetEvent();
+    expect($source.getState()).toEqual(0);
+  });
+});

test-typings/reset.ts

@@ -0,0 +1,39 @@
+import { expectType } from 'tsd';
+import { createEvent, createEffect, createStore } from 'effector';
+import { reset } from '../src/reset';
+
+import type { Event } from 'effector';
+
+// With clock in params
+{
+  const event = createEvent();
+  const $store = createStore('');
+  const $clock = createStore('');
+  const fx = createEffect();
+
+  expectType<void>(reset({ clock: event, target: $store }));
+  expectType<void>(reset({ clock: event, target: [$store] }));
+  expectType<void>(reset({ clock: [event], target: [$store] }));
+  expectType<void>(reset({ clock: [event], target: $store }));
+
+  expectType<void>(reset({ clock: fx, target: $store }));
+  expectType<void>(reset({ clock: fx, target: [$store] }));
+  expectType<void>(reset({ clock: [fx], target: [$store] }));
+  expectType<void>(reset({ clock: [fx], target: $store }));
+
+  expectType<void>(reset({ clock: $clock, target: $store }));
+  expectType<void>(reset({ clock: $clock, target: [$store] }));
+  expectType<void>(reset({ clock: [$clock], target: [$store] }));
+  expectType<void>(reset({ clock: [$clock], target: $store }));
+
+  expectType<void>(reset({ clock: [event, $clock, fx], target: $store }));
+  expectType<void>(reset({ clock: [event, $clock, fx], target: [$store] }));
+}
+
+// Without clock in params
+{
+  const $store = createStore('');
+
+  expectType<Event<void>>(reset({ target: $store }));
+  expectType<Event<void>>(reset({ target: [$store] }));
+}