Introduce the 'onlyIfChanged' operator

src/lib/util/genericOperators/index.ts

@@ -1,4 +1,5 @@
 export { throttleTime } from "./throttleTime";
 export { to } from "./to";
-export { nonNullable } from "./nonNullable";
-export { distinct } from "./distinct";
+export { nonNullable } from "./nonNullable";
+export { distinct } from "./distinct";
+export { onlyIfChanged } from "./onlyIfChanged";

src/lib/util/genericOperators/onlyIfChanged.ts

@@ -0,0 +1,30 @@
+
+import { Operator, NonPostableEvt } from "../../types";
+import { StatefulEvt } from "../../StatefulEvt";
+import { same } from "../../../tools/inDepth/same";
+
+const initialValue = {};
+
+export const onlyIfChanged= <T>(
+    params?: {
+        areEqual?: (a: T, b: T) => boolean;
+    }
+): Operator.fλ.Stateful<T, T> => {
+
+    const { areEqual = same } = params ?? {};
+
+    const op: Operator.fλ.Stateful<T, T> = [
+        function (this: NonPostableEvt<T>, data: T, prev: T) {
+            return (
+                this instanceof StatefulEvt ? 
+                areEqual(data, this.state) : 
+                prev === initialValue ? false : areEqual(data, prev)
+            ) ? null : [data];
+        },
+        initialValue as T
+    ] ;
+
+    return op;
+
+}
+

src/test/index.ts

@@ -31,7 +31,7 @@ if (n) {
 
     await new Promise(resolve => setTimeout(resolve, 2400));
 
-    const n = 108;
+    const n = 110;
 
     console.log({ n });
 

src/test/test109.ts

@@ -0,0 +1,27 @@
+import { Evt } from "../lib";
+import { assert } from "tsafe/assert";
+import { onlyIfChanged } from "../lib/util/genericOperators/onlyIfChanged";
+
+let alphabet = ""
+
+const evtFoo = Evt.create<{ foo: string; }>();
+
+evtFoo
+	.pipe(onlyIfChanged())
+	.attach(({ foo }) => {
+
+		alphabet += foo;
+
+	});
+
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "b" });
+evtFoo.post({ "foo": "b" });
+evtFoo.post({ "foo": "c" });
+
+assert(alphabet === "abc");
+
+console.log("PASS");
+

src/test/test110.ts

@@ -0,0 +1,27 @@
+import { Evt } from "../lib";
+import { assert } from "tsafe/assert";
+import { onlyIfChanged } from "../lib/util/genericOperators/onlyIfChanged";
+
+let alphabet = ""
+
+const evtFoo = Evt.create<{ foo: string; }>({ "foo": "a"});
+
+evtFoo
+	.pipe(onlyIfChanged())
+	.attach(({ foo }) => {
+
+		alphabet += foo;
+
+	});
+
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "a" });
+evtFoo.post({ "foo": "b" });
+evtFoo.post({ "foo": "b" });
+evtFoo.post({ "foo": "c" });
+
+assert(alphabet === "abc");
+
+console.log("PASS");
+