Patronum v2.1.0 (#314)

* Update homepage in package.json and npm website

* Add previous method (#313)

* Add previousValue method

* Add support for undefined

* Add store validation

* Add type tests

* Add `previousValue` to documentation root

* Rename `previousValue` to `previous`

* Add shorthands for common methods (#315)

* Add `debounce(source, timeout)` shorthand

* Add `delay(source, timeout)`

* Add `throttle(source, timeout)` shorthand

* add `status(fx)` shorthand

* Add `pending(effects)` shorthand

* Add `inFlight(effects)` shorthand

* Add `combineEvents(events)` shorthand

* Add `spread(targets)` shorthand

* Add `time(clock)` shorthand

* Update sids in snapshots

integration/cra/src/demo.test.ts

@@ -3,5 +3,5 @@ import { $pending } from './demo';
 test('should have sid', () => {
   expect($pending.sid).toBeDefined();
   expect($pending.sid).not.toBeNull();
-  expect($pending.sid).toMatchInlineSnapshot(`"-y29r2v|a37bj0"`);
+  expect($pending.sid).toMatchInlineSnapshot(`"-y29r2v|a4upb3"`);
 });

integration/custom/test/integration.spec.ts

@@ -29,7 +29,7 @@ test('status has sid', () => {
 
   expect($status.sid).toBeDefined();
   expect($status.sid).not.toBeNull();
-  expect($status.sid).toMatchInlineSnapshot(`"-o5m1b3|abrgim"`);
+  expect($status.sid).toMatchInlineSnapshot(`"-o5m1b3|ph7d4u"`);
 });
 
 test('pending macro works as expected', () => {
@@ -38,7 +38,7 @@ test('pending macro works as expected', () => {
 
   expect($pending.sid).toBeDefined();
   expect($pending.sid).not.toBeNull();
-  expect($pending.sid).toMatchInlineSnapshot(`"-hszfx7|a37bj0"`);
+  expect($pending.sid).toMatchInlineSnapshot(`"-hszfx7|a4upb3"`);
 });
 
 function waitFor<T>(unit: Event<T>) {

scripts/source.package.js

@@ -18,7 +18,7 @@ module.exports = () => ({
   bugs: {
     url: 'https://github.com/effector/patronum/issues',
   },
-  homepage: 'https://github.com/effector/patronum#readme',
+  homepage: 'https://patronum.effector.dev',
   peerDependencies: {
     effector: '^23',
   },

src/babel-plugin-factories.json

@@ -17,6 +17,7 @@
     "patronum/once",
     "patronum/or",
     "patronum/pending",
+    "patronum/previous",
     "patronum/reset",
     "patronum/reshape",
     "patronum/snapshot",
@@ -44,6 +45,7 @@
     "once": "once",
     "or": "or",
     "pending": "pending",
+    "previous": "previous",
     "reset": "reset",
     "reshape": "reshape",
     "snapshot": "snapshot",
@@ -54,4 +56,4 @@
     "throttle": "throttle",
     "time": "time"
   }
-}
+}

src/combine-events/combine-events.test.ts

@@ -150,6 +150,152 @@ test('source: shape', () => {
   `);
 });
 
+test('source: shape (shorthand)', () => {
+  const fn = jest.fn();
+
+  const event1 = createEvent<string | void>();
+  const event2 = createEvent<string | void>();
+  const event3 = createEvent<string | void>();
+  const event4 = createEvent<string | void>();
+  const event5 = createEvent<string | void>();
+
+  type Target = Event<{
+    event1: string | void;
+    event2: string | void;
+    event3: string | void;
+    event4: string | void;
+    event5: string | void;
+  }>;
+
+  const event: Target = combineEvents({
+    event1,
+    event2,
+    event3,
+    event4,
+    event5,
+  });
+
+  event.watch(fn);
+
+  event1();
+  event1();
+  event2('-');
+  event3('c');
+  event2('b');
+  event2();
+  event4();
+  event4('d');
+  event5('e');
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      {
+        "event1": undefined,
+        "event2": undefined,
+        "event3": "c",
+        "event4": "d",
+        "event5": "e",
+      },
+    ]
+  `);
+
+  event1('a');
+  event2('-');
+  event3();
+  event2('b');
+  event3();
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      {
+        "event1": undefined,
+        "event2": undefined,
+        "event3": "c",
+        "event4": "d",
+        "event5": "e",
+      },
+    ]
+  `);
+  event4('-');
+  event4();
+  event5('e');
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      {
+        "event1": undefined,
+        "event2": undefined,
+        "event3": "c",
+        "event4": "d",
+        "event5": "e",
+      },
+      {
+        "event1": "a",
+        "event2": "b",
+        "event3": undefined,
+        "event4": undefined,
+        "event5": "e",
+      },
+    ]
+  `);
+
+  event1('1');
+  event2('-');
+  event3('-');
+  event2('2');
+  event3('3');
+  event4('-');
+  event4('4');
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      {
+        "event1": undefined,
+        "event2": undefined,
+        "event3": "c",
+        "event4": "d",
+        "event5": "e",
+      },
+      {
+        "event1": "a",
+        "event2": "b",
+        "event3": undefined,
+        "event4": undefined,
+        "event5": "e",
+      },
+    ]
+  `);
+
+  event5('5');
+  event5('-');
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      {
+        "event1": undefined,
+        "event2": undefined,
+        "event3": "c",
+        "event4": "d",
+        "event5": "e",
+      },
+      {
+        "event1": "a",
+        "event2": "b",
+        "event3": undefined,
+        "event4": undefined,
+        "event5": "e",
+      },
+      {
+        "event1": "1",
+        "event2": "2",
+        "event3": "3",
+        "event4": "4",
+        "event5": "5",
+      },
+    ]
+  `);
+});
+
 test('source: array', () => {
   const fn = jest.fn();
 
@@ -225,6 +371,79 @@ test('source: array', () => {
   `);
 });
 
+test('source: array (shorthand)', () => {
+  const fn = jest.fn();
+
+  const event1 = createEvent<string | void>();
+  const event2 = createEvent<string | void>();
+  const event3 = createEvent<string | void>();
+  const event4 = createEvent<string | void>();
+  const event5 = createEvent<string | void>();
+
+  type Target = Event<
+    [string | void, string | void, string | void, string | void, string | void]
+  >;
+
+  const event: Target = combineEvents([event1, event2, event3, event4, event5]);
+
+  event.watch(fn);
+
+  event1();
+  event1();
+  event2('-');
+  event3('c');
+  event2('b');
+  event2();
+  event4();
+  event4('d');
+  event5('e');
+
+  event1('a');
+  event2('-');
+  event3();
+  event2('b');
+  event3();
+  event4('-');
+  event4();
+  event5('e');
+
+  event1('1');
+  event2('-');
+  event3('-');
+  event2('2');
+  event3('3');
+  event4('-');
+  event4('4');
+  event5('5');
+  event5('-');
+
+  expect(argumentHistory(fn)).toMatchInlineSnapshot(`
+    [
+      [
+        undefined,
+        undefined,
+        "c",
+        "d",
+        "e",
+      ],
+      [
+        "a",
+        "b",
+        undefined,
+        undefined,
+        "e",
+      ],
+      [
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+      ],
+    ]
+  `);
+});
+
 test('example from readme', () => {
   const fn = jest.fn();
 

src/combine-events/index.ts

@@ -5,7 +5,6 @@ import {
   Event,
   EventAsReturnType,
   is,
-  merge,
   sample,
   Store,
   Unit,
@@ -44,15 +43,21 @@ export function combineEvents<
   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>({
-  events,
-  reset,
-  target = createEvent(),
-}: {
-  events: Events<any>;
-  reset?: Unit<any>;
-  target?: UnitTargetable<any> | Unit<any>;
-}) {
+export function combineEvents<P extends Shape>(
+  events: Events<P>,
+): EventAsReturnType<P>;
+
+export function combineEvents<P>(
+  args:
+    | {
+        events: Events<any>;
+        reset?: Unit<any>;
+        target?: UnitTargetable<any> | Unit<any>;
+      }
+    | Events<any>,
+) {
+  const argsShape = isEventsShape(args) ? { events: args } : args;
+  const { events, reset, target = createEvent() } = argsShape;
   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');
@@ -64,11 +69,11 @@ export function combineEvents<P>({
     const $counter = createStore(keys.length, { serialize: 'ignore' });
     const $results = createStore(defaultShape, { serialize: 'ignore' });
 
-    $counter.reset(sample({ source: target }));
+    sample({ source: target, target: $counter.reinit });
     $results.reset(target);
 
     if (reset) {
-      $counter.reset(sample({ source: reset }));
+      sample({ source: reset, target: $counter.reinit });
       $results.reset(reset);
     }
 
@@ -104,6 +109,12 @@ export function combineEvents<P>({
   return target;
 }
 
+function isEventsShape<P>(args: any): args is Events<any> {
+  return Object.keys(args).some(
+    (key) => !['events', 'reset', 'target'].includes(key) && is.unit(args[key]),
+  );
+}
+
 function throwError(message: string) {
   throw new Error(message);
 }