synstate 5.0.1 → 6.0.0

package/README.md

@@ -336,7 +336,7 @@ assert.deepStrictEqual(countHistory, [0, 0, 2]);
 
 ### Keeping the Parts an Update Did Not Change (`keepEqualParts`)
 
-A state written whole from a source that answers with a new object every time, such as a server polled for a report, can take `keepEqualParts: true`. The next state is compared with the current one before it is written: every part deeply equal to the same part of the current state is replaced by that part, so whatever reads an unchanged part keeps the object it has and `skipIfNoChange()` with `Object.is` stops it, and an answer that changes nothing is not passed on at all. Array items are matched by index; `keepEqualParts: { key }` matches them by key. The comparison is `replaceEqualDeep` of ts-data-forge, which serves any other write too.
+A state written whole from a source that answers with a new object every time, such as a server polled for a report, can take `keepEqualParts: true`. The next state is compared with the current one before it is written: every part deeply equal to the same part of the current state is replaced by that part, so whatever reads an unchanged part keeps the object it has and `map`, comparing with `Object.is`, stops there, and an answer that changes nothing is not passed on at all. Array items are matched by index; `keepEqualParts: { key }` matches them by key. The comparison is `replaceEqualDeep` of ts-data-forge, which serves any other write too.
 
 ```tsx
 type PullReport = DeepReadonly<{
@@ -349,7 +349,7 @@ const [report, setReport] = createState<PullReport>(
     { keepEqualParts: true },
 );
 
-const summary = report.pipe(map((r) => r.summary)).pipe(skipIfNoChange());
+const summary = report.pipe(map((r) => r.summary));
 
 const summaryHistory: unknown[] = [];
 

package/dist/core/operators/keep-equal-parts.d.mts

@@ -41,9 +41,7 @@ import type { KeepInitialValueOperator } from '../types/index.mjs';
  *
  * const board$ = message$.pipe(keepEqualParts());
  *
- * const firstCard$ = board$
- *   .pipe(map((board) => board.cards[0]))
- *   .pipe(skipIfNoChange());
+ * const firstCard$ = board$.pipe(map((board) => board.cards[0]));
  *
  * const boardHistory: Board[] = [];
  *

package/dist/core/operators/keep-equal-parts.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"keep-equal-parts.d.mts","sourceRoot":"","sources":["../../../src/core/operators/keep-equal-parts.mts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAEV,wBAAwB,EAGzB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,YACpB,uBAAuB,KAChC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"keep-equal-parts.d.mts","sourceRoot":"","sources":["../../../src/core/operators/keep-equal-parts.mts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,uBAAuB,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAEV,wBAAwB,EAGzB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,YACpB,uBAAuB,KAChC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}

package/dist/core/operators/keep-equal-parts.mjs

@@ -83,8 +83,6 @@ import { SyncChildObservableClass } from '../class/index.mjs';
 
 
 
-
-
 
 
 

package/dist/core/operators/keep-equal-parts.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"keep-equal-parts.mjs","sourceRoot":"","sources":["../../../src/core/operators/keep-equal-parts.mts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,6EAA6E;AAC7E,yCAAyC;AACzC,2CAA2C;AAC3C,gDAAgD;AAChD,0DAA0D;AAC1D,kEAAkE;AAClE,OAAO,EACL,QAAQ,EACR,gBAAgB,GAEjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAQ9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,OAAiC,EACD,EAAE;AAClC,4DAA4D;AAC5D,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,IAAI,6BAA6B,CAC/B,gBAAgB,EAChB,OAAO,CACR,CAAmC,CAAC;AAEzC,MAAM,6BACJ,SAAQ,wBAAyC;IAGxC,QAAQ,CAAsC;IACvD,kBAAkB,CAAc;IAEhC,YACE,gBAA+B,EAC/B,OAA4C;QAE5C,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;SAC7C,CAAC,CAAC;QAEH,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEzD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QAExB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEQ,SAAS,CAAC,WAAwB;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAE5B,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QAE7B,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3D,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAErC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;YAE7B,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAEpC,OAAO;QACT,CAAC;QAED,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEnE,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QAED,sDAAsD;QACtD,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC;YACjD,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAClC,CAAC;CACF"}
+{"version":3,"file":"keep-equal-parts.mjs","sourceRoot":"","sources":["../../../src/core/operators/keep-equal-parts.mts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,6EAA6E;AAC7E,yCAAyC;AACzC,2CAA2C;AAC3C,gDAAgD;AAChD,0DAA0D;AAC1D,kEAAkE;AAClE,OAAO,EACL,QAAQ,EACR,gBAAgB,GAEjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAQ9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,OAAiC,EACD,EAAE;AAClC,4DAA4D;AAC5D,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,IAAI,6BAA6B,CAC/B,gBAAgB,EAChB,OAAO,CACR,CAAmC,CAAC;AAEzC,MAAM,6BACJ,SAAQ,wBAAyC;IAGxC,QAAQ,CAAsC;IACvD,kBAAkB,CAAc;IAEhC,YACE,gBAA+B,EAC/B,OAA4C;QAE5C,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,gBAAgB,CAAC,WAAW,EAAE;SAC7C,CAAC,CAAC;QAEH,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAEzD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QAExB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEQ,SAAS,CAAC,WAAwB;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAE5B,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QAE7B,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3D,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,kBAAkB,CAAC;QAErC,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;YAE7B,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAEpC,OAAO;QACT,CAAC;QAED,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEnE,IAAI,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QAED,sDAAsD;QACtD,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC;YACjD,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;IAClC,CAAC;CACF"}

package/dist/core/operators/map.d.mts

@@ -1,42 +1,54 @@
-import { SafeUint } from 'ts-data-forge';
 import type { KeepInitialValueOperator } from '../types/index.mjs';
 /**
- * Transforms each value emitted by the source using a mapping function that also receives the emission index.
+ * Transforms each value emitted by the source with a mapping function, and
+ * emits the result unless it equals the one already held.
+ *
+ * The comparison is `Object.is` unless `equals` says otherwise, so a result
+ * that did not change wakes nothing below. To pass on every result — an event
+ * turned into a value, say — give `equals: () => false`, or use `mapTo`. The
+ * mapping function receives the value alone; `withIndex` attaches an index.
  *
  * @template A - The type of values from the source
  * @template B - The type of mapped values
- * @param mapFn - A function that maps each value (receives value and index)
- * @returns An operator that maps values with index
+ * @param mapFn - A function that maps each value
+ * @param options - `equals` compares a result with the one held
+ * @returns An operator that maps values
  *
  * @example
  * ```ts
  * //  Timeline:
  * //
- * //  num$      "A"      "B"      "C"
- * //  indexed$  "0: A"   "1: B"   "2: C"
+ * //  num$      1   3   4   6   7
+ * //  parity$   1       0       1
  * //
  * //  Explanation:
- * //  - mapWithIndex transforms each value along with its index
- * //  - Index starts at 0 and increments with each emission
+ * //  - map transforms each value
+ * //  - A result equal to the one held is not emitted
  *
- * const num$ = source<string>();
+ * const num$ = source<number>();
  *
- * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));
+ * const parity$ = num$.pipe(map((x) => x % 2));
  *
- * const valueHistory: string[] = [];
+ * const valueHistory: number[] = [];
  *
- * indexed$.subscribe((s) => {
- *   valueHistory.push(s);
+ * parity$.subscribe((p) => {
+ *   valueHistory.push(p);
  * });
  *
- * num$.next('A'); // 0: A
+ * num$.next(1); // 1
+ *
+ * num$.next(3); // still 1: not emitted
+ *
+ * num$.next(4); // 0
  *
- * num$.next('B'); // 1: B
+ * num$.next(6); // still 0: not emitted
  *
- * num$.next('C'); // 2: C
+ * num$.next(7); // 1
  *
- * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);
+ * assert.deepStrictEqual(valueHistory, [1, 0, 1]);
  * ```
  */
-export declare const map: <A, B>(mapFn: (x: A, index: SafeUint | -1) => B) => KeepInitialValueOperator<A, B>;
+export declare const map: <A, B>(mapFn: (x: A) => B, options?: Readonly<{
+    equals?: (x: B, y: B) => boolean;
+}>) => KeepInitialValueOperator<A, B>;
 //# sourceMappingURL=map.d.mts.map

package/dist/core/operators/map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"AAOA,OAAO,EAAY,QAAQ,EAA0B,MAAM,eAAe,CAAC;AAG3E,OAAO,KAAK,EAEV,wBAAwB,EAIzB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,SACf,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,KACvC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAMQ,CAAC"}
+{"version":3,"file":"map.d.mts","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAEV,wBAAwB,EAIzB,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,SACf,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,YACR,QAAQ,CAAC;IAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;CAAE,CAAC,KACvD,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAOQ,CAAC"}

package/dist/core/operators/map.mjs

@@ -5,7 +5,7 @@
 
 
 
-import { Optional, SafeUint, asSafeUint } from 'ts-data-forge';
+import { Optional } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 
 
@@ -47,20 +47,31 @@ import { SyncChildObservableClass } from '../class/index.mjs';
 
 
 
-export const map = (mapFn) => 
 
-((parentObservable) => new MapObservableClass(parentObservable, mapFn));
+
+
+
+
+
+
+
+
+
+
+export const map = (mapFn, options) => 
+
+((parentObservable) => new MapObservableClass(parentObservable, mapFn, options?.equals ?? Object.is));
 
 class MapObservableClass extends SyncChildObservableClass {
     #mapFn;
-    #mut_index;
-    constructor(parentObservable, mapFn) {
+    #equals;
+    constructor(parentObservable, mapFn, equals) {
         super({
             parents: [parentObservable],
-            initialValue: Optional.map(parentObservable.getSnapshot(), (x) => mapFn(x, -1)),
+            initialValue: Optional.map(parentObservable.getSnapshot(), mapFn),
         });
-        this.#mut_index = -1;
         this.#mapFn = mapFn;
+        this.#equals = equals;
         this.attach();
     }
     tryUpdate(updateToken) {
@@ -69,9 +80,12 @@ class MapObservableClass extends SyncChildObservableClass {
         if (par.updateToken !== updateToken || Optional.isNone(sn)) {
             return;
         }
-        this.#mut_index =
-            this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
-        this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);
+        const next = this.#mapFn(sn.value);
+        const held = this.getSnapshot();
+        if (Optional.isSome(held) && this.#equals(held.value, next)) {
+            return;
+        }
+        this.setNext(next, updateToken);
     }
 }
 

package/dist/core/operators/map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map.mjs","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"map.mjs","sourceRoot":"","sources":["../../../src/core/operators/map.mts"],"names":[],"mappings":"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"}

package/dist/core/predefined/operators/attach-index.d.mts

@@ -1,8 +1,10 @@
-import type { SafeUint } from 'ts-type-forge';
+import { SafeUint } from 'ts-data-forge';
 import type { KeepInitialValueOperator } from '../../types/index.mjs';
 /**
  * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
- * Index starts at 0 and increments with each emission.
+ * Index starts at 0 and increments with each emission; a value the source
+ * already holds when this is applied gets -1. Use it where `map` used to
+ * receive an index.
  *
  * @template A - The type of values from the source
  * @returns An operator that emits `[index, value]` tuples

package/dist/core/predefined/operators/attach-index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"attach-index.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CACM,CAAC;AAEpC;;;GAGG;AACH,eAAO,MAAM,WAAW,kBAAY,CAAC"}
+{"version":3,"file":"attach-index.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AAOA,OAAO,EAAY,QAAQ,EAAc,MAAM,eAAe,CAAC;AAE/D,OAAO,KAAK,EACV,wBAAwB,EAGzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,OAAM,wBAAwB,CACvD,CAAC,EACD,SAAS,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAO1B,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,WAAW,kBAAY,CAAC"}

package/dist/core/predefined/operators/attach-index.mjs

@@ -1,4 +1,3 @@
-import { map } from '../../operators/index.mjs';
 
 
 
@@ -6,6 +5,8 @@ import { map } from '../../operators/index.mjs';
 
 
 
+import { Optional, SafeUint, asSafeUint } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../../class/index.mjs';
 
 
 
@@ -48,10 +49,43 @@ import { map } from '../../operators/index.mjs';
 
 
 
-export const withIndex = () => map((a, i) => [i, a]);
+
+
+
+
+
+
+
+
+
+export const withIndex = () => 
+
+((parentObservable) => new WithIndexObservableClass(parentObservable));
 
 
 
 
 export const attachIndex = withIndex;
+
+class WithIndexObservableClass extends SyncChildObservableClass {
+    #mut_index;
+    constructor(parentObservable) {
+        super({
+            parents: [parentObservable],
+            initialValue: Optional.map(parentObservable.getSnapshot(), (a) => [-1, a]),
+        });
+        this.#mut_index = -1;
+        this.attach();
+    }
+    tryUpdate(updateToken) {
+        const par = this.parents[0];
+        const sn = par.getSnapshot();
+        if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+            return;
+        }
+        this.#mut_index =
+            this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+        this.setNext([this.#mut_index, sn.value], updateToken);
+    }
+}
 //# sourceMappingURL=attach-index.mjs.map

package/dist/core/predefined/operators/attach-index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"attach-index.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAGvB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAU,CAAC,CAAC;AAEpC;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC"}
+{"version":3,"file":"attach-index.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,6EAA6E;AAC7E,yCAAyC;AACzC,2CAA2C;AAC3C,gDAAgD;AAChD,0DAA0D;AAC1D,kEAAkE;AAClE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAOjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAGvB,EAAE;AACF,4DAA4D;AAC5D,CAAC,CAAC,gBAAgB,EAAE,EAAE,CACpB,IAAI,wBAAwB,CAAC,gBAAgB,CAAC,CAG/C,CAAC;AAEJ;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;AAErC,oBAAoB;AAEpB,MAAM,wBAA4B,SAAQ,wBAGzC;IACC,UAAU,CAAgB;IAE1B,YAAY,gBAA+B;QACzC,KAAK,CAAC;YACJ,OAAO,EAAE,CAAC,gBAAgB,CAAC;YAC3B,YAAY,EAAE,QAAQ,CAAC,GAAG,CACxB,gBAAgB,CAAC,WAAW,EAAE,EAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAU,CACxB;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QAErB,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAEQ,SAAS,CAAC,WAAwB;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAE5B,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QAE7B,IAAI,GAAG,CAAC,WAAW,KAAK,WAAW,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3D,OAAO,CAAC,cAAc;QACxB,CAAC;QAED,IAAI,CAAC,UAAU;YACb,IAAI,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAE5E,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;IACzD,CAAC;CACF"}

package/dist/core/predefined/operators/map-to.d.mts

@@ -1,7 +1,11 @@
 import type { KeepInitialValueOperator } from '../../types/index.mjs';
 /**
  * Maps all emitted values to a constant value, ignoring the source values.
- * Equivalent to `map(() => value)`.
+ * Emits on every source value although the value never changes — where
+ * `map(() => value)` would stop every result after the first as equal — so
+ * it is the one for turning events into a value. The value's type is
+ * inferred as written, as with `as const`: `mapTo('reset')` gives
+ * `'reset'`, not `string`.
  *
  * @template A - The type of values from the source
  * @template B - The type of the constant value
@@ -39,5 +43,5 @@ import type { KeepInitialValueOperator } from '../../types/index.mjs';
  * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
  * ```
  */
-export declare const mapTo: <A, B>(value: B) => KeepInitialValueOperator<A, B>;
+export declare const mapTo: <A, const B>(value: B) => KeepInitialValueOperator<A, B>;
 //# sourceMappingURL=map-to.d.mts.map

package/dist/core/predefined/operators/map-to.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAClD,CAAC"}
+{"version":3,"file":"map-to.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,KAAK,CAAC,CAAC,SAAS,CAAC,KAAG,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAC/B,CAAC"}

package/dist/core/predefined/operators/map-to.mjs

@@ -39,5 +39,9 @@ import { map } from '../../operators/index.mjs';
 
 
 
-export const mapTo = (value) => map(() => value);
+
+
+
+
+export const mapTo = (value) => map(() => value, { equals: () => false });
 //# sourceMappingURL=map-to.mjs.map

package/dist/core/predefined/operators/map-to.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-to.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAO,KAAQ,EAAkC,EAAE,CACtE,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC"}
+{"version":3,"file":"map-to.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-to.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAa,KAAQ,EAAkC,EAAE,CAC5E,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC"}

package/dist/utils/create-reducer.d.mts

@@ -110,7 +110,7 @@ export type StateOptions<S> = Readonly<{
      * written, and every part of it deeply equal to the same part of the
      * current state is replaced by that part (`replaceEqualDeep` of
      * ts-data-forge): a reader of an unchanged part keeps the object it has, so
-     * `skipIfNoChange()` with `Object.is` stops it. When the whole next state is
+     * `map`, comparing with `Object.is`, stops there. When the whole next state is
      * deeply equal, the current state is kept and nothing is passed on, so
      * `equals` can stay `Object.is`.
      *

package/dist/utils/create-state.d.mts

@@ -80,7 +80,7 @@ import { type StateOptions } from './create-reducer.mjs';
  *   { keepEqualParts: true },
  * );
  *
- * const summary = report.pipe(map((r) => r.summary)).pipe(skipIfNoChange());
+ * const summary = report.pipe(map((r) => r.summary));
  *
  * const summaryHistory: unknown[] = [];
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synstate",
-  "version": "5.0.1",
+  "version": "6.0.0",
   "description": "Type-safe State Management Library for TypeScript/JavaScript",
   "repository": {
     "type": "git",
@@ -51,8 +51,8 @@
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.3.1",
     "rxjs": "7.8.2",
-    "synstate-react-hooks": "5.0.1",
-    "synstate-react-hooks-compat": "5.0.1",
+    "synstate-react-hooks": "6.0.0",
+    "synstate-react-hooks-compat": "6.0.0",
     "ts-repo-utils": "10.7.1",
     "valtio": "2.3.2",
     "zustand": "5.0.15"

package/src/core/operators/keep-equal-parts.mts

@@ -59,9 +59,7 @@ import type {
  *
  * const board$ = message$.pipe(keepEqualParts());
  *
- * const firstCard$ = board$
- *   .pipe(map((board) => board.cards[0]))
- *   .pipe(skipIfNoChange());
+ * const firstCard$ = board$.pipe(map((board) => board.cards[0]));
  *
  * const boardHistory: Board[] = [];
  *

package/src/core/operators/map-cut-off.test.mts

@@ -0,0 +1,215 @@
+import { expectType } from 'ts-data-forge';
+import { combine } from '../combine/index.mjs';
+import { source } from '../create/index.mjs';
+import { mapTo, withIndex } from '../predefined/index.mjs';
+import type { Observable } from '../types/index.mjs';
+import { map } from './map.mjs';
+
+describe('map stops a result equal to the one it holds', () => {
+  test('a result equal by Object.is is not emitted', () => {
+    const a$ = source<number>();
+
+    const parity$ = a$.pipe(map((x) => x % 2));
+
+    const mut_history: number[] = [];
+
+    parity$.subscribe((p) => {
+      mut_history.push(p);
+    });
+
+    a$.next(1);
+
+    a$.next(3);
+
+    a$.next(4);
+
+    a$.next(6);
+
+    a$.next(7);
+
+    assert.deepStrictEqual(mut_history, [1, 0, 1]);
+  });
+
+  test('the value computed from an initial value counts as the one held', () => {
+    const a$ = source<number>(1);
+
+    const parity$ = a$.pipe(map((x) => x % 2));
+
+    const mut_history: number[] = [];
+
+    parity$.subscribe((p) => {
+      mut_history.push(p);
+    });
+
+    a$.next(3);
+
+    a$.next(4);
+
+    assert.deepStrictEqual(mut_history, [1, 0]);
+  });
+
+  test('a node below is not woken when the result is equal', () => {
+    const a$ = source<number>(1);
+
+    const parity$ = a$.pipe(map((x) => x % 2));
+
+    let mut_calls = 0;
+
+    const label$ = parity$.pipe(
+      map((p) => {
+        mut_calls += 1;
+
+        return p === 0 ? 'even' : 'odd';
+      }),
+    );
+
+    label$.subscribe(() => {});
+
+    const callsAfterSetup = mut_calls;
+
+    a$.next(3);
+
+    a$.next(5);
+
+    assert.strictEqual(mut_calls, callsAfterSetup);
+
+    a$.next(6);
+
+    assert.strictEqual(mut_calls, callsAfterSetup + 1);
+  });
+
+  test('a node reading a stopped map and another parent still updates once', () => {
+    const a$ = source<number>(1);
+
+    const parity$ = a$.pipe(map((x) => x % 2));
+
+    const mut_history: string[] = [];
+
+    combine([a$, parity$]).subscribe(([a, p]) => {
+      mut_history.push(`${a.toString()},${p.toString()}`);
+    });
+
+    a$.next(3);
+
+    a$.next(4);
+
+    assert.deepStrictEqual(mut_history, ['1,1', '3,1', '4,0']);
+  });
+
+  test('NaN equals NaN, and 0 differs from -0, as Object.is says', () => {
+    const a$ = source<number>();
+
+    const r$ = a$.pipe(map((x) => x));
+
+    const mut_history: number[] = [];
+
+    r$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    a$.next(Number.NaN);
+
+    a$.next(Number.NaN);
+
+    a$.next(0);
+
+    a$.next(-0);
+
+    assert.deepStrictEqual(mut_history, [Number.NaN, 0, -0]);
+  });
+
+  test('`equals` replaces Object.is', () => {
+    const a$ = source<Readonly<{ id: number; name: string }>>();
+
+    const id$ = a$.pipe(
+      map((x) => ({ id: x.id }), { equals: (p, q) => p.id === q.id }),
+    );
+
+    const mut_history: number[] = [];
+
+    id$.subscribe(({ id }) => {
+      mut_history.push(id);
+    });
+
+    a$.next({ id: 1, name: 'a' });
+
+    a$.next({ id: 1, name: 'b' });
+
+    a$.next({ id: 2, name: 'b' });
+
+    assert.deepStrictEqual(mut_history, [1, 2]);
+  });
+
+  test('`equals: () => false` emits every result', () => {
+    const click$ = source<undefined>();
+
+    const one$ = click$.pipe(map(() => 1, { equals: () => false }));
+
+    const mut_history: number[] = [];
+
+    one$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    click$.next(undefined);
+
+    click$.next(undefined);
+
+    assert.deepStrictEqual(mut_history, [1, 1]);
+  });
+
+  test('the mapping function no longer receives an index', () => {
+    const a$ = source<number>();
+
+    // @ts-expect-error `map` passes the value alone; use `withIndex`.
+    const r$ = a$.pipe(map((x: number, i: number) => x + i));
+
+    expect(r$).toBeDefined();
+  });
+});
+
+describe('operators that turn events into values emit every event', () => {
+  test('mapTo emits its value on every event', () => {
+    const reset$ = source<undefined>();
+
+    const action$ = reset$.pipe(mapTo('reset'));
+
+    expectType<typeof action$, Observable<'reset'>>('=');
+
+    const mut_history: string[] = [];
+
+    action$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    reset$.next(undefined);
+
+    reset$.next(undefined);
+
+    assert.deepStrictEqual(mut_history, ['reset', 'reset']);
+  });
+
+  test('withIndex counts from 0, and gives -1 to an initial value', () => {
+    const a$ = source<string>('init');
+
+    const indexed$ = a$.pipe(withIndex());
+
+    assert.deepStrictEqual(indexed$.getSnapshot().value, [-1, 'init']);
+
+    const mut_history: (readonly [number, string])[] = [];
+
+    indexed$.subscribe((v) => {
+      mut_history.push(v);
+    });
+
+    a$.next('x');
+
+    a$.next('x');
+
+    assert.deepStrictEqual(mut_history, [
+      [-1, 'init'],
+      [0, 'x'],
+      [1, 'x'],
+    ]);
+  });
+});

package/src/core/operators/map.mts

@@ -5,7 +5,7 @@
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
 // @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
-import { Optional, SafeUint, asSafeUint, expectType } from 'ts-data-forge';
+import { Optional, expectType } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import { source } from '../create/index.mjs';
 import type {
@@ -18,51 +18,64 @@ import type {
 import { withInitialValue } from './with-initial-value.mjs';
 
 /**
- * Transforms each value emitted by the source using a mapping function that also receives the emission index.
+ * Transforms each value emitted by the source with a mapping function, and
+ * emits the result unless it equals the one already held.
+ *
+ * The comparison is `Object.is` unless `equals` says otherwise, so a result
+ * that did not change wakes nothing below. To pass on every result — an event
+ * turned into a value, say — give `equals: () => false`, or use `mapTo`. The
+ * mapping function receives the value alone; `withIndex` attaches an index.
  *
  * @template A - The type of values from the source
  * @template B - The type of mapped values
- * @param mapFn - A function that maps each value (receives value and index)
- * @returns An operator that maps values with index
+ * @param mapFn - A function that maps each value
+ * @param options - `equals` compares a result with the one held
+ * @returns An operator that maps values
  *
  * @example
  * ```ts
  * //  Timeline:
  * //
- * //  num$      "A"      "B"      "C"
- * //  indexed$  "0: A"   "1: B"   "2: C"
+ * //  num$      1   3   4   6   7
+ * //  parity$   1       0       1
  * //
  * //  Explanation:
- * //  - mapWithIndex transforms each value along with its index
- * //  - Index starts at 0 and increments with each emission
+ * //  - map transforms each value
+ * //  - A result equal to the one held is not emitted
  *
- * const num$ = source<string>();
+ * const num$ = source<number>();
  *
- * const indexed$ = num$.pipe(map((x, i) => `${i}: ${x}`));
+ * const parity$ = num$.pipe(map((x) => x % 2));
  *
- * const valueHistory: string[] = [];
+ * const valueHistory: number[] = [];
  *
- * indexed$.subscribe((s) => {
- *   valueHistory.push(s);
+ * parity$.subscribe((p) => {
+ *   valueHistory.push(p);
  * });
  *
- * num$.next('A'); // 0: A
+ * num$.next(1); // 1
+ *
+ * num$.next(3); // still 1: not emitted
  *
- * num$.next('B'); // 1: B
+ * num$.next(4); // 0
  *
- * num$.next('C'); // 2: C
+ * num$.next(6); // still 0: not emitted
  *
- * assert.deepStrictEqual(valueHistory, ['0: A', '1: B', '2: C']);
+ * num$.next(7); // 1
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 0, 1]);
  * ```
  */
 export const map = <A, B>(
-  mapFn: (x: A, index: SafeUint | -1) => B,
+  mapFn: (x: A) => B,
+  options?: Readonly<{ equals?: (x: B, y: B) => boolean }>,
 ): KeepInitialValueOperator<A, B> =>
   // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
   ((parentObservable) =>
     new MapObservableClass(
       parentObservable,
       mapFn,
+      options?.equals ?? Object.is,
     )) as KeepInitialValueOperator<A, B>;
 
 /* implementation */
@@ -71,24 +84,23 @@ class MapObservableClass<A, B>
   extends SyncChildObservableClass<B, readonly [A]>
   implements MapOperatorObservable<A, B>
 {
-  readonly #mapFn: (x: A, index: SafeUint | -1) => B;
-  #mut_index: SafeUint | -1;
+  readonly #mapFn: (x: A) => B;
+  readonly #equals: (x: B, y: B) => boolean;
 
   constructor(
     parentObservable: Observable<A>,
-    mapFn: (x: A, index: SafeUint | -1) => B,
+    mapFn: (x: A) => B,
+    equals: (x: B, y: B) => boolean,
   ) {
     super({
       parents: [parentObservable],
-      initialValue: Optional.map(parentObservable.getSnapshot(), (x) =>
-        mapFn(x, -1),
-      ),
+      initialValue: Optional.map(parentObservable.getSnapshot(), mapFn),
     });
 
-    this.#mut_index = -1;
-
     this.#mapFn = mapFn;
 
+    this.#equals = equals;
+
     this.attach();
   }
 
@@ -101,10 +113,15 @@ class MapObservableClass<A, B>
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    const next = this.#mapFn(sn.value);
+
+    const held = this.getSnapshot();
+
+    if (Optional.isSome(held) && this.#equals(held.value, next)) {
+      return; // the result did not change
+    }
 
-    this.setNext(this.#mapFn(sn.value, this.#mut_index), updateToken);
+    this.setNext(next, updateToken);
   }
 }
 
@@ -116,7 +133,7 @@ if (import.meta.vitest !== undefined) {
   {
     const s: Observable<number> = source<number>();
 
-    const _d1 = s.pipe(map((x, i) => x + i));
+    const _d1 = s.pipe(map((x) => x + 1));
 
     expectType<typeof _d1, Observable<number>>('=');
   }
@@ -126,7 +143,7 @@ if (import.meta.vitest !== undefined) {
 
     const m: InitializedObservable<number> = s.pipe(withInitialValue(0));
 
-    const _d = m.pipe(map((x, i) => x + i));
+    const _d = m.pipe(map((x) => x + 1));
 
     expectType<typeof _d, InitializedObservable<number>>('=');
   }

package/src/core/predefined/operators/attach-index.mts

@@ -1,10 +1,23 @@
-import type { SafeUint } from 'ts-type-forge';
-import { map } from '../../operators/index.mjs';
-import type { KeepInitialValueOperator } from '../../types/index.mjs';
+// Sumi bans classes, `this`, method syntax and writes to `this` outside a
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
+// so those rules are waived here (D-63).
+// @sumi-expect-error-file classes/no-class
+// @sumi-expect-error-file banned-syntax/no-this
+// @sumi-expect-error-file functions/prefer-arrow-function
+// @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
+import { Optional, SafeUint, asSafeUint } from 'ts-data-forge';
+import { SyncChildObservableClass } from '../../class/index.mjs';
+import type {
+  KeepInitialValueOperator,
+  Observable,
+  UpdateToken,
+} from '../../types/index.mjs';
 
 /**
  * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.
- * Index starts at 0 and increments with each emission.
+ * Index starts at 0 and increments with each emission; a value the source
+ * already holds when this is applied gets -1. Use it where `map` used to
+ * receive an index.
  *
  * @template A - The type of values from the source
  * @returns An operator that emits `[index, value]` tuples
@@ -54,10 +67,54 @@ import type { KeepInitialValueOperator } from '../../types/index.mjs';
 export const withIndex = <A,>(): KeepInitialValueOperator<
   A,
   readonly [SafeUint | -1, A]
-> => map((a, i) => [i, a] as const);
+> =>
+  // @sumi-expect-error banned-syntax/no-unsafe-type-assertion
+  ((parentObservable) =>
+    new WithIndexObservableClass(parentObservable)) as KeepInitialValueOperator<
+    A,
+    readonly [SafeUint | -1, A]
+  >;
 
 /**
  * Alias for `withIndex`.
  * @see withIndex
  */
 export const attachIndex = withIndex;
+
+/* implementation */
+
+class WithIndexObservableClass<A> extends SyncChildObservableClass<
+  readonly [SafeUint | -1, A],
+  readonly [A]
+> {
+  #mut_index: SafeUint | -1;
+
+  constructor(parentObservable: Observable<A>) {
+    super({
+      parents: [parentObservable],
+      initialValue: Optional.map(
+        parentObservable.getSnapshot(),
+        (a) => [-1, a] as const,
+      ),
+    });
+
+    this.#mut_index = -1;
+
+    this.attach();
+  }
+
+  override tryUpdate(updateToken: UpdateToken): void {
+    const par = this.parents[0];
+
+    const sn = par.getSnapshot();
+
+    if (par.updateToken !== updateToken || Optional.isNone(sn)) {
+      return; // skip update
+    }
+
+    this.#mut_index =
+      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+
+    this.setNext([this.#mut_index, sn.value], updateToken);
+  }
+}

package/src/core/predefined/operators/map-to.mts

@@ -3,7 +3,11 @@ import type { KeepInitialValueOperator } from '../../types/index.mjs';
 
 /**
  * Maps all emitted values to a constant value, ignoring the source values.
- * Equivalent to `map(() => value)`.
+ * Emits on every source value although the value never changes — where
+ * `map(() => value)` would stop every result after the first as equal — so
+ * it is the one for turning events into a value. The value's type is
+ * inferred as written, as with `as const`: `mapTo('reset')` gives
+ * `'reset'`, not `string`.
  *
  * @template A - The type of values from the source
  * @template B - The type of the constant value
@@ -41,5 +45,5 @@ import type { KeepInitialValueOperator } from '../../types/index.mjs';
  * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
  * ```
  */
-export const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>
-  map(() => value);
+export const mapTo = <A, const B>(value: B): KeepInitialValueOperator<A, B> =>
+  map(() => value, { equals: () => false });

package/src/utils/create-reducer.mts

@@ -150,7 +150,7 @@ export type StateOptions<S> = Readonly<{
    * written, and every part of it deeply equal to the same part of the
    * current state is replaced by that part (`replaceEqualDeep` of
    * ts-data-forge): a reader of an unchanged part keeps the object it has, so
-   * `skipIfNoChange()` with `Object.is` stops it. When the whole next state is
+   * `map`, comparing with `Object.is`, stops there. When the whole next state is
    * deeply equal, the current state is kept and nothing is passed on, so
    * `equals` can stay `Object.is`.
    *

package/src/utils/create-state.mts

@@ -102,7 +102,7 @@ const reducer = <S,>(state: S, action: Action<S>): S => {
  *   { keepEqualParts: true },
  * );
  *
- * const summary = report.pipe(map((r) => r.summary)).pipe(skipIfNoChange());
+ * const summary = report.pipe(map((r) => r.summary));
  *
  * const summaryHistory: unknown[] = [];
  *