synstate 0.1.2 → 1.0.0

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

@@ -1,5 +1,47 @@
-import { map } from './map.mjs';
+import 'ts-data-forge';
+import '../../utils/id-maker.mjs';
+import { map } from '../../operators/map.mjs';
 
+/**
+ * Maps all emitted values to a constant value, ignoring the source values.
+ * Equivalent to `map(() => value)`.
+ *
+ * @template A - The type of values from the source
+ * @template B - The type of the constant value
+ * @param value - The constant value to emit
+ * @returns An operator that always emits the given constant
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  click$    MouseEvent   MouseEvent   MouseEvent
+ * //  count$    1            1            1
+ * //
+ * //  Explanation:
+ * //  - mapTo maps all emitted values to a constant value
+ * //  - Ignores the source values entirely
+ * //  - Useful for converting events to signals
+ *
+ * const click$ = source<string>();
+ *
+ * const one$ = click$.pipe(mapTo(1));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * one$.subscribe((value) => {
+ *   valueHistory.push(value);
+ * });
+ *
+ * click$.next('click1');
+ *
+ * click$.next('click2');
+ *
+ * click$.next('click3');
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 1, 1]);
+ * ```
+ */
 const mapTo = (value) => map(() => value);
 
 export { mapTo };

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

@@ -1 +1 @@
-{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGO,MAAM,KAAK,GAAG,CAAO,KAAQ,KAClC,GAAG,CAAC,MAAM,KAAK;;;;"}
+{"version":3,"file":"map-to.mjs","sources":["../../../../src/core/predefined/operators/map-to.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,KAAK,GAAG,CAAO,KAAQ,KAClC,GAAG,CAAC,MAAM,KAAK;;;;"}

package/dist/core/predefined/operators/pluck.d.mts

@@ -1,4 +1,43 @@
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Extracts a property value from each emitted object by key.
+ * Equivalent to `map(value => value[key])`.
+ *
+ * @template A - The type of the emitted object
+ * @template K - The key to extract
+ * @param key - The property key to pluck
+ * @returns An operator that emits the property value
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  user$   { name: "Alice", age: 25 }   { name: "Bob", age: 30 }
+ * //  name$   "Alice"                       "Bob"
+ * //
+ * //  Explanation:
+ * //  - getKey extracts a property value from each emitted object
+ * //  - Equivalent to map(value => value[key])
+ *
+ * const user$ = source<Readonly<{ name: string; age: number }>>();
+ *
+ * const name$ = user$.pipe(getKey('name'));
+ *
+ * const valueHistory: string[] = [];
+ *
+ * name$.subscribe((n) => {
+ *   valueHistory.push(n);
+ * });
+ *
+ * user$.next({ name: 'Alice', age: 25 });
+ *
+ * assert.deepStrictEqual(valueHistory, ['Alice']);
+ *
+ * user$.next({ name: 'Bob', age: 30 });
+ *
+ * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);
+ * ```
+ */
 export declare const pluck: <A, K extends keyof A>(key: K) => KeepInitialValueOperator<A, A[K]>;
 /**
  * Alias for `pluck`.

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

@@ -1 +1 @@
-{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,KAAK,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,GARG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAMR,CAAC"}
+{"version":3,"file":"pluck.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,KAAK,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAuB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,MAAM,GARG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,OACnC,CAAC,KACL,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAMR,CAAC"}

package/dist/core/predefined/operators/pluck.mjs

@@ -1,5 +1,46 @@
-import { map } from './map.mjs';
+import 'ts-data-forge';
+import '../../utils/id-maker.mjs';
+import { map } from '../../operators/map.mjs';
 
+/**
+ * Extracts a property value from each emitted object by key.
+ * Equivalent to `map(value => value[key])`.
+ *
+ * @template A - The type of the emitted object
+ * @template K - The key to extract
+ * @param key - The property key to pluck
+ * @returns An operator that emits the property value
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  user$   { name: "Alice", age: 25 }   { name: "Bob", age: 30 }
+ * //  name$   "Alice"                       "Bob"
+ * //
+ * //  Explanation:
+ * //  - getKey extracts a property value from each emitted object
+ * //  - Equivalent to map(value => value[key])
+ *
+ * const user$ = source<Readonly<{ name: string; age: number }>>();
+ *
+ * const name$ = user$.pipe(getKey('name'));
+ *
+ * const valueHistory: string[] = [];
+ *
+ * name$.subscribe((n) => {
+ *   valueHistory.push(n);
+ * });
+ *
+ * user$.next({ name: 'Alice', age: 25 });
+ *
+ * assert.deepStrictEqual(valueHistory, ['Alice']);
+ *
+ * user$.next({ name: 'Bob', age: 30 });
+ *
+ * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);
+ * ```
+ */
 const pluck = (key) => map((a) => a[key]);
 /**
  * Alias for `pluck`.

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

@@ -1 +1 @@
-{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":[null],"names":[],"mappings":";;MAGa,KAAK,GAAG,CACnB,GAAM,KACgC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;AAEzD;;;AAGG;AACI,MAAM,MAAM,GAAG;;;;"}
+{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;MACU,KAAK,GAAG,CACnB,GAAM,KACgC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;AAEzD;;;AAGG;AACI,MAAM,MAAM,GAAG;;;;"}

package/dist/core/predefined/operators/skip.d.mts

@@ -1,3 +1,50 @@
 import { type DropInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Skips the first `n` emissions from the source observable.
+ * After `n` values are skipped, all subsequent values pass through.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to skip
+ * @returns An operator that skips the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$      1     2     3     4     5
+ * //  skipped$              3     4     5
+ * //            |skip 2|
+ * //
+ * //  Explanation:
+ * //  - skip ignores the first n emissions from the source
+ * //  - After n values are skipped, all subsequent values pass through
+ *
+ * const num$ = source<number>();
+ *
+ * const skipped$ = num$.pipe(skip(2));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * skipped$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1); // skipped
+ *
+ * num$.next(2); // skipped
+ *
+ * assert.deepStrictEqual(valueHistory, []);
+ *
+ * num$.next(3); // logs: 3
+ *
+ * assert.deepStrictEqual(valueHistory, [3]);
+ *
+ * num$.next(4); // logs: 4
+ *
+ * num$.next(5); // logs: 5
+ *
+ * assert.deepStrictEqual(valueHistory, [3, 4, 5]);
+ * ```
+ */
 export declare const skip: <A>(n: PositiveSafeIntWithSmallInt) => DropInitialValueOperator<A, A>;
 //# sourceMappingURL=skip.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}
+{"version":3,"file":"skip.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CACyC,CAAC"}

package/dist/core/predefined/operators/skip.mjs

@@ -2,6 +2,53 @@ import { PositiveSafeInt } from 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { skipWhile } from '../../operators/skip-while.mjs';
 
+/**
+ * Skips the first `n` emissions from the source observable.
+ * After `n` values are skipped, all subsequent values pass through.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to skip
+ * @returns An operator that skips the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$      1     2     3     4     5
+ * //  skipped$              3     4     5
+ * //            |skip 2|
+ * //
+ * //  Explanation:
+ * //  - skip ignores the first n emissions from the source
+ * //  - After n values are skipped, all subsequent values pass through
+ *
+ * const num$ = source<number>();
+ *
+ * const skipped$ = num$.pipe(skip(2));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * skipped$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1); // skipped
+ *
+ * num$.next(2); // skipped
+ *
+ * assert.deepStrictEqual(valueHistory, []);
+ *
+ * num$.next(3); // logs: 3
+ *
+ * assert.deepStrictEqual(valueHistory, [3]);
+ *
+ * num$.next(4); // logs: 4
+ *
+ * num$.next(5); // logs: 5
+ *
+ * assert.deepStrictEqual(valueHistory, [3, 4, 5]);
+ * ```
+ */
 const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
 const idFn = (value) => value;
 

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

@@ -1 +1 @@
-{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIO,MAAM,IAAI,GAAG,CAClB,CAA8B,KAE9B,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;AAExE,MAAM,IAAI,GAAG,CAAK,KAAQ,KAAQ,KAAK;;;;"}
+{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CG;AACI,MAAM,IAAI,GAAG,CAClB,CAA8B,KAE9B,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;AAExE,MAAM,IAAI,GAAG,CAAK,KAAQ,KAAQ,KAAK;;;;"}

package/dist/core/predefined/operators/take.d.mts

@@ -1,3 +1,44 @@
 import { type DropInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Takes only the first `n` emissions from the source observable, then completes.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to take
+ * @returns An operator that takes the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$    1     2     3     4 (ignored)
+ * //  taken$  1     2     3     | (completes)
+ * //
+ * //  Explanation:
+ * //  - take emits only the first n values, then completes
+ * //  - Subsequent emissions from the source are ignored
+ *
+ * const num$ = source<number>();
+ *
+ * const taken$ = num$.pipe(take(3));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * taken$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1);
+ *
+ * num$.next(2);
+ *
+ * num$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ *
+ * num$.next(4); // ignored (already completed)
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ * ```
+ */
 export declare const take: <A>(n: PositiveSafeIntWithSmallInt) => DropInitialValueOperator<A, A>;
 //# sourceMappingURL=take.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"take.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/take.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}
+{"version":3,"file":"take.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/take.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EACpB,GAAG,2BAA2B,KAC7B,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}

package/dist/core/predefined/operators/take.mjs

@@ -2,6 +2,47 @@ import 'ts-data-forge';
 import '../../utils/id-maker.mjs';
 import { takeWhile } from '../../operators/take-while.mjs';
 
+/**
+ * Takes only the first `n` emissions from the source observable, then completes.
+ *
+ * @template A - The type of values from the source
+ * @param n - The number of values to take
+ * @returns An operator that takes the first n emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  num$    1     2     3     4 (ignored)
+ * //  taken$  1     2     3     | (completes)
+ * //
+ * //  Explanation:
+ * //  - take emits only the first n values, then completes
+ * //  - Subsequent emissions from the source are ignored
+ *
+ * const num$ = source<number>();
+ *
+ * const taken$ = num$.pipe(take(3));
+ *
+ * const valueHistory: number[] = [];
+ *
+ * taken$.subscribe((x) => {
+ *   valueHistory.push(x);
+ * });
+ *
+ * num$.next(1);
+ *
+ * num$.next(2);
+ *
+ * num$.next(3);
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ *
+ * num$.next(4); // ignored (already completed)
+ *
+ * assert.deepStrictEqual(valueHistory, [1, 2, 3]);
+ * ```
+ */
 const take = (n) => takeWhile((_, index) => index + 1 <= n);
 
 export { take };

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

@@ -1 +1 @@
-{"version":3,"file":"take.mjs","sources":["../../../../src/core/predefined/operators/take.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGO,MAAM,IAAI,GAAG,CAClB,CAA8B,KACK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;;;;"}
+{"version":3,"file":"take.mjs","sources":["../../../../src/core/predefined/operators/take.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACI,MAAM,IAAI,GAAG,CAClB,CAA8B,KACK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,GAAG,CAAC,IAAI,CAAC;;;;"}

package/dist/core/predefined/operators/unwrap-optional.d.mts

@@ -1,4 +1,44 @@
 import { Optional } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Unwraps `Optional` values, converting `Some(value)` to `value` and `None` to `undefined`.
+ *
+ * @template O - The Optional type from the source
+ * @returns An operator that unwraps Optional emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  opt$        Some(42)    None        Some(7)
+ * //  unwrapped$  42          undefined   7
+ * //
+ * //  Explanation:
+ * //  - unwrapOptional converts Some(value) to value, and None to undefined
+ * //  - Useful for extracting raw values from Optional streams
+ *
+ * const opt$ = source<Optional<number>>();
+ *
+ * const unwrapped$ = opt$.pipe(unwrapOptional());
+ *
+ * const valueHistory: (number | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * opt$.next(Optional.some(42));
+ *
+ * assert.deepStrictEqual(valueHistory, [42]);
+ *
+ * opt$.next(Optional.none);
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined]);
+ *
+ * opt$.next(Optional.some(7));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
+ * ```
+ */
 export declare const unwrapOptional: <O extends UnknownOptional>() => KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined>;
 //# sourceMappingURL=unwrap-optional.d.mts.map

package/dist/core/predefined/operators/unwrap-optional.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-optional.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,eAAe,OACtB,wBAAwB,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC"}
+{"version":3,"file":"unwrap-optional.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,eAAe,OACtB,wBAAwB,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC"}

package/dist/core/predefined/operators/unwrap-optional.mjs

@@ -1,6 +1,47 @@
 import { Optional } from 'ts-data-forge';
-import { map } from './map.mjs';
+import '../../utils/id-maker.mjs';
+import { map } from '../../operators/map.mjs';
 
+/**
+ * Unwraps `Optional` values, converting `Some(value)` to `value` and `None` to `undefined`.
+ *
+ * @template O - The Optional type from the source
+ * @returns An operator that unwraps Optional emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  opt$        Some(42)    None        Some(7)
+ * //  unwrapped$  42          undefined   7
+ * //
+ * //  Explanation:
+ * //  - unwrapOptional converts Some(value) to value, and None to undefined
+ * //  - Useful for extracting raw values from Optional streams
+ *
+ * const opt$ = source<Optional<number>>();
+ *
+ * const unwrapped$ = opt$.pipe(unwrapOptional());
+ *
+ * const valueHistory: (number | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * opt$.next(Optional.some(42));
+ *
+ * assert.deepStrictEqual(valueHistory, [42]);
+ *
+ * opt$.next(Optional.none);
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined]);
+ *
+ * opt$.next(Optional.some(7));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
+ * ```
+ */
 const unwrapOptional = () => 
 // eslint-disable-next-line total-functions/no-unsafe-type-assertion
 map(Optional.unwrap);

package/dist/core/predefined/operators/unwrap-optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-optional.mjs","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIO,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,QAAQ,CAAC,MAA+C;;;;"}
+{"version":3,"file":"unwrap-optional.mjs","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,cAAc,GAAG;AAG5B;AACA,GAAG,CAAC,QAAQ,CAAC,MAA+C;;;;"}

package/dist/core/predefined/operators/unwrap-result-err.d.mts

@@ -1,4 +1,44 @@
 import { Result } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.
+ *
+ * @template R - The Result type from the source
+ * @returns An operator that unwraps the Err side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$     Ok(1)      Err("fail")   Ok(2)
+ * //  unwrapped$  undefined  "fail"        undefined
+ * //
+ * //  Explanation:
+ * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined
+ * //  - Useful for extracting error values from Result streams
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const unwrapped$ = result$.pipe(unwrapResultErr());
+ *
+ * const valueHistory: (string | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(1));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined]);
+ *
+ * result$.next(Result.err('fail'));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);
+ *
+ * result$.next(Result.ok(2));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);
+ * ```
+ */
 export declare const unwrapResultErr: <R extends UnknownResult>() => KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined>;
 //# sourceMappingURL=unwrap-result-err.d.mts.map

package/dist/core/predefined/operators/unwrap-result-err.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-err.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,eAAO,MAAM,eAAe,GAC1B,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CACC,CAAC"}
+{"version":3,"file":"unwrap-result-err.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,eAAe,GAC1B,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CACC,CAAC"}

package/dist/core/predefined/operators/unwrap-result-err.mjs

@@ -1,6 +1,47 @@
 import { Result } from 'ts-data-forge';
-import { map } from './map.mjs';
+import '../../utils/id-maker.mjs';
+import { map } from '../../operators/map.mjs';
 
+/**
+ * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.
+ *
+ * @template R - The Result type from the source
+ * @returns An operator that unwraps the Err side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$     Ok(1)      Err("fail")   Ok(2)
+ * //  unwrapped$  undefined  "fail"        undefined
+ * //
+ * //  Explanation:
+ * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined
+ * //  - Useful for extracting error values from Result streams
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const unwrapped$ = result$.pipe(unwrapResultErr());
+ *
+ * const valueHistory: (string | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(1));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined]);
+ *
+ * result$.next(Result.err('fail'));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);
+ *
+ * result$.next(Result.ok(2));
+ *
+ * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);
+ * ```
+ */
 const unwrapResultErr = () => map(Result.unwrapErr);
 
 export { unwrapResultErr };

package/dist/core/predefined/operators/unwrap-result-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-err.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIO,MAAM,eAAe,GAAG,MAG7B,GAAG,CAAC,MAAM,CAAC,SAAmD;;;;"}
+{"version":3,"file":"unwrap-result-err.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCG;AACI,MAAM,eAAe,GAAG,MAG7B,GAAG,CAAC,MAAM,CAAC,SAAmD;;;;"}

package/dist/core/predefined/operators/unwrap-result-ok.d.mts

@@ -1,4 +1,44 @@
 import { Result } from 'ts-data-forge';
 import { type KeepInitialValueOperator } from '../../types/index.mjs';
+/**
+ * Unwraps the success value from a `Result`, converting `Ok(value)` to `value` and `Err` to `undefined`.
+ *
+ * @template R - The Result type from the source
+ * @returns An operator that unwraps the Ok side of Result emissions
+ *
+ * @example
+ * ```ts
+ * //  Timeline:
+ * //
+ * //  result$     Ok(42)    Err("e")    Ok(7)
+ * //  unwrapped$  42        undefined   7
+ * //
+ * //  Explanation:
+ * //  - unwrapResultOk converts Ok(value) to value, and Err to undefined
+ * //  - Useful for extracting success values from Result streams
+ *
+ * const result$ = source<Result<number, string>>();
+ *
+ * const unwrapped$ = result$.pipe(unwrapResultOk());
+ *
+ * const valueHistory: (number | undefined)[] = [];
+ *
+ * unwrapped$.subscribe((v) => {
+ *   valueHistory.push(v);
+ * });
+ *
+ * result$.next(Result.ok(42));
+ *
+ * assert.deepStrictEqual(valueHistory, [42]);
+ *
+ * result$.next(Result.err('e'));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined]);
+ *
+ * result$.next(Result.ok(7));
+ *
+ * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);
+ * ```
+ */
 export declare const unwrapResultOk: <R extends UnknownResult>() => KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined>;
 //# sourceMappingURL=unwrap-result-ok.d.mts.map

package/dist/core/predefined/operators/unwrap-result-ok.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC"}
+{"version":3,"file":"unwrap-result-ok.d.mts","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,cAAc,GACzB,CAAC,SAAS,aAAa,OACpB,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAEA,CAAC"}