synstate 3.0.0 → 3.0.1

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

@@ -1 +1 @@
-{"version":3,"file":"map-result-err.mjs","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the error value (`Err`) of a `Result` type emitted by the source.\n * If the value is `Err`, the mapping function is applied; if `Ok`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template E2 - The type of the mapped error value\n * @param mapFn - A function to transform the Err value\n * @returns An operator that maps the Err side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(1)    Err(\"bad\")      Err(\"fail\")\n * //  mapped$   Ok(1)    Err(\"BAD\")      Err(\"FAIL\")\n * //\n * //  Explanation:\n * //  - mapResultErr transforms the Err value of Result emissions\n * //  - Ok values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const mapped$ = result$.pipe(mapResultErr((e) => e.toUpperCase()));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * mapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(1));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1)]);\n *\n * result$.next(Result.err('bad'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(1), Result.err('BAD')]);\n *\n * result$.next(Result.err('fail'));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(1),\n *   Result.err('BAD'),\n *   Result.err('FAIL'),\n * ]);\n * ```\n */\nexport const mapResultErr = <R extends UnknownResult, E2>(\n  mapFn: (x: Result.UnwrapErr<R>) => E2,\n): KeepInitialValueOperator<R, Result<Result.UnwrapOk<R>, E2>> =>\n  map(Result.mapErr(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,eAAe,CAC1B,KAAA,KAEA,IAAI,MAAA,CAAO,MAAA,CAAO,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-err.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,KAAqC,EACwB,EAAE,CAC/D,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC"}

package/dist/core/predefined/operators/map-result-ok.mjs

@@ -1,8 +1,51 @@
 import { Result } from 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const mapResultOk = (mapFn) => map(Result.map(mapFn));
 
-export { mapResultOk };
-//# sourceMappingURL=map-result-ok.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const mapResultOk = (mapFn) => map(Result.map(mapFn));
+//# sourceMappingURL=map-result-ok.mjs.map

package/dist/core/predefined/operators/map-result-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"map-result-ok.mjs","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the success value (`Ok`) of a `Result` type emitted by the source.\n * If the value is `Ok`, the mapping function is applied; if `Err`, it remains unchanged.\n *\n * @template R - The Result type from the source\n * @template S2 - The type of the mapped success value\n * @param mapFn - A function to transform the Ok value\n * @returns An operator that maps the Ok side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$   Ok(2)      Err(\"e\")   Ok(5)\n * //  doubled$  Ok(4)      Err(\"e\")   Ok(10)\n * //\n * //  Explanation:\n * //  - mapResultOk transforms the Ok value of Result emissions\n * //  - Err values pass through unchanged\n *\n * const result$ = source<Result<number, string>>();\n *\n * const doubled$ = result$.pipe(mapResultOk((x) => x * 2));\n *\n * const valueHistory: Result<number, string>[] = [];\n *\n * doubled$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(2));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4)]);\n *\n * result$.next(Result.err('e'));\n *\n * assert.deepStrictEqual(valueHistory, [Result.ok(4), Result.err('e')]);\n *\n * result$.next(Result.ok(5));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Result.ok(4),\n *   Result.err('e'),\n *   Result.ok(10),\n * ]);\n * ```\n */\nexport const mapResultOk = <R extends UnknownResult, S2>(\n  mapFn: (x: Result.UnwrapOk<R>) => S2,\n): KeepInitialValueOperator<R, Result<S2, Result.UnwrapErr<R>>> =>\n  map(Result.map(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,cAAc,CACzB,KAAA,KAEA,IAAI,MAAA,CAAO,GAAA,CAAI,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-result-ok.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,KAAoC,EAC0B,EAAE,CAChE,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC"}

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

@@ -1,8 +1,43 @@
-import 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const mapTo = (value) => map(() => value);
 
-export { mapTo };
-//# sourceMappingURL=map-to.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const mapTo = (value) => map(() => value);
+//# sourceMappingURL=map-to.mjs.map

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":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Maps all emitted values to a constant value, ignoring the source values.\n * Equivalent to `map(() => value)`.\n *\n * @template A - The type of values from the source\n * @template B - The type of the constant value\n * @param value - The constant value to emit\n * @returns An operator that always emits the given constant\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  click$    MouseEvent   MouseEvent   MouseEvent\n * //  count$    1            1            1\n * //\n * //  Explanation:\n * //  - mapTo maps all emitted values to a constant value\n * //  - Ignores the source values entirely\n * //  - Useful for converting events to signals\n *\n * const click$ = source<string>();\n *\n * const one$ = click$.pipe(mapTo(1));\n *\n * const valueHistory: number[] = [];\n *\n * one$.subscribe((value) => {\n *   valueHistory.push(value);\n * });\n *\n * click$.next('click1');\n *\n * click$.next('click2');\n *\n * click$.next('click3');\n *\n * assert.deepStrictEqual(valueHistory, [1, 1, 1]);\n * ```\n */\nexport const mapTo = <A, B>(value: B): KeepInitialValueOperator<A, B> =>\n  map(() => value);\n"],"names":[],"mappings":";;;;AA2CO,MAAM,KAAA,GAAQ,CAAO,KAAA,KAC1B,GAAA,CAAI,MAAM,KAAK;;;;"}
+{"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"}

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

@@ -1,9 +1,47 @@
-import 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const pluck = (key) => map((a) => a[key]);
-const getKey = pluck;
 
-export { getKey, pluck };
-//# sourceMappingURL=pluck.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const pluck = (key) => map((a) => a[key]);
+
+
+
+
+export const getKey = pluck;
+//# sourceMappingURL=pluck.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"pluck.mjs","sources":["../../../../src/core/predefined/operators/pluck.mts"],"sourcesContent":["import { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Extracts a property value from each emitted object by key.\n * Equivalent to `map(value => value[key])`.\n *\n * @template A - The type of the emitted object\n * @template K - The key to extract\n * @param key - The property key to pluck\n * @returns An operator that emits the property value\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  user$   { name: \"Alice\", age: 25 }   { name: \"Bob\", age: 30 }\n * //  name$   \"Alice\"                       \"Bob\"\n * //\n * //  Explanation:\n * //  - getKey extracts a property value from each emitted object\n * //  - Equivalent to map(value => value[key])\n *\n * const user$ = source<Readonly<{ name: string; age: number }>>();\n *\n * const name$ = user$.pipe(getKey('name'));\n *\n * const valueHistory: string[] = [];\n *\n * name$.subscribe((n) => {\n *   valueHistory.push(n);\n * });\n *\n * user$.next({ name: 'Alice', age: 25 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice']);\n *\n * user$.next({ name: 'Bob', age: 30 });\n *\n * assert.deepStrictEqual(valueHistory, ['Alice', 'Bob']);\n * ```\n */\nexport const pluck = <A, K extends keyof A>(\n  key: K,\n): KeepInitialValueOperator<A, A[K]> => map((a) => a[key]);\n\n/**\n * Alias for `pluck`.\n * @see pluck\n */\nexport const getKey = pluck;\n"],"names":[],"mappings":";;;;AA0CO,MAAM,KAAA,GAAQ,CACnB,GAAA,KACsC,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,CAAE,GAAG,CAAC;AAMlD,MAAM,MAAA,GAAS;;;;"}
+{"version":3,"file":"pluck.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/pluck.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,GAAM,EAC6B,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAE3D;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,KAAK,CAAC"}

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

@@ -1,9 +1,52 @@
 import { PositiveSafeInt } from 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { skipWhile } from '../../operators/skip-while.mjs';
+import { skipWhile } from '../../operators/index.mjs';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
-const idFn = (value) => value;
 
-export { skip };
-//# sourceMappingURL=skip.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const skip = (n) => !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);
+const idFn = (value) => value;
+//# sourceMappingURL=skip.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"skip.mjs","sources":["../../../../src/core/predefined/operators/skip.mts"],"sourcesContent":["import { PositiveSafeInt } from 'ts-data-forge';\nimport { type PositiveSafeIntWithSmallInt } from 'ts-type-forge';\nimport { skipWhile } from '../../operators/index.mjs';\nimport { type DropInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Skips the first `n` emissions from the source observable.\n * After `n` values are skipped, all subsequent values pass through.\n *\n * @template A - The type of values from the source\n * @param n - The number of values to skip\n * @returns An operator that skips the first n emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$      1     2     3     4     5\n * //  skipped$              3     4     5\n * //            |skip 2|\n * //\n * //  Explanation:\n * //  - skip ignores the first n emissions from the source\n * //  - After n values are skipped, all subsequent values pass through\n *\n * const num$ = source<number>();\n *\n * const skipped$ = num$.pipe(skip(2));\n *\n * const valueHistory: number[] = [];\n *\n * skipped$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1); // skipped\n *\n * num$.next(2); // skipped\n *\n * assert.deepStrictEqual(valueHistory, []);\n *\n * num$.next(3); // logs: 3\n *\n * assert.deepStrictEqual(valueHistory, [3]);\n *\n * num$.next(4); // logs: 4\n *\n * num$.next(5); // logs: 5\n *\n * assert.deepStrictEqual(valueHistory, [3, 4, 5]);\n * ```\n */\nexport const skip = <A,>(\n  n: PositiveSafeIntWithSmallInt,\n): DropInitialValueOperator<A, A> =>\n  !PositiveSafeInt.is(n) ? idFn : skipWhile((_, index) => index + 1 <= n);\n\nconst idFn = <T,>(value: T): T => value;\n"],"names":[],"mappings":";;;;AAoDO,MAAM,IAAA,GAAO,CAClB,CAAA,KAEA,CAAC,gBAAgB,EAAA,CAAG,CAAC,CAAA,GAAI,IAAA,GAAO,UAAU,CAAC,CAAA,EAAG,KAAA,KAAU,KAAA,GAAQ,KAAK,CAAC;AAExE,MAAM,IAAA,GAAO,CAAK,KAAA,KAAgB,KAAA;;;;"}
+{"version":3,"file":"skip.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/skip.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,CAA8B,EACE,EAAE,CAClC,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AAE1E,MAAM,IAAI,GAAG,CAAK,KAAQ,EAAK,EAAE,CAAC,KAAK,CAAC"}

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

@@ -1,8 +1,44 @@
-import 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { takeWhile } from '../../operators/take-while.mjs';
+import { takeWhile } from '../../operators/index.mjs';
 
-const take = (n) => takeWhile((_, index) => index + 1 <= n);
 
-export { take };
-//# sourceMappingURL=take.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const take = (n) => takeWhile((_, index) => index + 1 <= n);
+//# sourceMappingURL=take.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"take.mjs","sources":["../../../../src/core/predefined/operators/take.mts"],"sourcesContent":["import { type PositiveSafeIntWithSmallInt } from 'ts-type-forge';\nimport { takeWhile } from '../../operators/index.mjs';\nimport { type DropInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Takes only the first `n` emissions from the source observable, then completes.\n *\n * @template A - The type of values from the source\n * @param n - The number of values to take\n * @returns An operator that takes the first n emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  num$    1     2     3     4 (ignored)\n * //  taken$  1     2     3     | (completes)\n * //\n * //  Explanation:\n * //  - take emits only the first n values, then completes\n * //  - Subsequent emissions from the source are ignored\n *\n * const num$ = source<number>();\n *\n * const taken$ = num$.pipe(take(3));\n *\n * const valueHistory: number[] = [];\n *\n * taken$.subscribe((x) => {\n *   valueHistory.push(x);\n * });\n *\n * num$.next(1);\n *\n * num$.next(2);\n *\n * num$.next(3);\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n *\n * num$.next(4); // ignored (already completed)\n *\n * assert.deepStrictEqual(valueHistory, [1, 2, 3]);\n * ```\n */\nexport const take = <A,>(\n  n: PositiveSafeIntWithSmallInt,\n): DropInitialValueOperator<A, A> => takeWhile((_, index) => index + 1 <= n);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,IAAA,GAAO,CAClB,CAAA,KACmC,SAAA,CAAU,CAAC,CAAA,EAAG,KAAA,KAAU,KAAA,GAAQ,CAAA,IAAK,CAAC;;;;"}
+{"version":3,"file":"take.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/take.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,CAA8B,EACE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC"}

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

@@ -1,11 +1,46 @@
 import { Optional } from 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const unwrapOptional = () => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  map(Optional.unwrap)
-);
 
-export { unwrapOptional };
-//# sourceMappingURL=unwrap-optional.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const unwrapOptional = () => 
+
+map(Optional.unwrap);
+//# sourceMappingURL=unwrap-optional.mjs.map

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":["import { Optional, type UnknownOptional } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps `Optional` values, converting `Some(value)` to `value` and `None` to `undefined`.\n *\n * @template O - The Optional type from the source\n * @returns An operator that unwraps Optional emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  opt$        Some(42)    None        Some(7)\n * //  unwrapped$  42          undefined   7\n * //\n * //  Explanation:\n * //  - unwrapOptional converts Some(value) to value, and None to undefined\n * //  - Useful for extracting raw values from Optional streams\n *\n * const opt$ = source<Optional<number>>();\n *\n * const unwrapped$ = opt$.pipe(unwrapOptional());\n *\n * const valueHistory: (number | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * opt$.next(Optional.some(42));\n *\n * assert.deepStrictEqual(valueHistory, [42]);\n *\n * opt$.next(Optional.none);\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined]);\n *\n * opt$.next(Optional.some(7));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);\n * ```\n */\nexport const unwrapOptional = <\n  O extends UnknownOptional,\n>(): KeepInitialValueOperator<O, Optional.Unwrap<O> | undefined> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  map(Optional.unwrap as Fn<O, Optional.Unwrap<O> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,cAAA,GAAiB;AAAA;AAAA,EAI5B,GAAA,CAAI,SAAS,MAA+C;AAAA;;;;"}
+{"version":3,"file":"unwrap-optional.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAEmC,EAAE;AACjE,oEAAoE;AACpE,GAAG,CAAC,QAAQ,CAAC,MAA+C,CAAC,CAAC"}

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

@@ -1,8 +1,44 @@
 import { Result } from 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const unwrapResultErr = () => map(Result.unwrapErr);
 
-export { unwrapResultErr };
-//# sourceMappingURL=unwrap-result-err.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const unwrapResultErr = () => map(Result.unwrapErr);
+//# sourceMappingURL=unwrap-result-err.mjs.map

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":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps the error value from a `Result`, converting `Err(error)` to `error` and `Ok` to `undefined`.\n *\n * @template R - The Result type from the source\n * @returns An operator that unwraps the Err side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$     Ok(1)      Err(\"fail\")   Ok(2)\n * //  unwrapped$  undefined  \"fail\"        undefined\n * //\n * //  Explanation:\n * //  - unwrapResultErr converts Err(error) to error, and Ok to undefined\n * //  - Useful for extracting error values from Result streams\n *\n * const result$ = source<Result<number, string>>();\n *\n * const unwrapped$ = result$.pipe(unwrapResultErr());\n *\n * const valueHistory: (string | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(1));\n *\n * assert.deepStrictEqual(valueHistory, [undefined]);\n *\n * result$.next(Result.err('fail'));\n *\n * assert.deepStrictEqual(valueHistory, [undefined, 'fail']);\n *\n * result$.next(Result.ok(2));\n *\n * assert.deepStrictEqual(valueHistory, [undefined, 'fail', undefined]);\n * ```\n */\nexport const unwrapResultErr = <\n  R extends UnknownResult,\n>(): KeepInitialValueOperator<R, Result.UnwrapErr<R> | undefined> =>\n  map(Result.unwrapErr as Fn<R, Result.UnwrapErr<R> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,eAAA,GAAkB,MAG7B,GAAA,CAAI,MAAA,CAAO,SAAmD;;;;"}
+{"version":3,"file":"unwrap-result-err.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-err.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,GAEmC,EAAE,CAClE,GAAG,CAAC,MAAM,CAAC,SAAmD,CAAC,CAAC"}

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

@@ -1,11 +1,46 @@
 import { Result } from 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const unwrapResultOk = () => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  map(Result.unwrapOk)
-);
 
-export { unwrapResultOk };
-//# sourceMappingURL=unwrap-result-ok.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const unwrapResultOk = () => 
+
+map(Result.unwrapOk);
+//# sourceMappingURL=unwrap-result-ok.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"unwrap-result-ok.mjs","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"sourcesContent":["import { Result, type UnknownResult } from 'ts-data-forge';\nimport { type Fn } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Unwraps the success value from a `Result`, converting `Ok(value)` to `value` and `Err` to `undefined`.\n *\n * @template R - The Result type from the source\n * @returns An operator that unwraps the Ok side of Result emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  result$     Ok(42)    Err(\"e\")    Ok(7)\n * //  unwrapped$  42        undefined   7\n * //\n * //  Explanation:\n * //  - unwrapResultOk converts Ok(value) to value, and Err to undefined\n * //  - Useful for extracting success values from Result streams\n *\n * const result$ = source<Result<number, string>>();\n *\n * const unwrapped$ = result$.pipe(unwrapResultOk());\n *\n * const valueHistory: (number | undefined)[] = [];\n *\n * unwrapped$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * result$.next(Result.ok(42));\n *\n * assert.deepStrictEqual(valueHistory, [42]);\n *\n * result$.next(Result.err('e'));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined]);\n *\n * result$.next(Result.ok(7));\n *\n * assert.deepStrictEqual(valueHistory, [42, undefined, 7]);\n * ```\n */\nexport const unwrapResultOk = <\n  R extends UnknownResult,\n>(): KeepInitialValueOperator<R, Result.UnwrapOk<R> | undefined> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  map(Result.unwrapOk as Fn<R, Result.UnwrapOk<R> | undefined>);\n"],"names":[],"mappings":";;;;AA6CO,MAAM,cAAA,GAAiB;AAAA;AAAA,EAI5B,GAAA,CAAI,OAAO,QAAiD;AAAA;;;;"}
+{"version":3,"file":"unwrap-result-ok.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/unwrap-result-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAsB,MAAM,eAAe,CAAC;AAE3D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAEmC,EAAE;AACjE,oEAAoE;AACpE,GAAG,CAAC,MAAM,CAAC,QAAiD,CAAC,CAAC"}

package/dist/core/types/id.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=id.mjs.map
+export {};
+//# sourceMappingURL=id.mjs.map

package/dist/core/types/id.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"id.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"id.mjs","sourceRoot":"","sources":["../../../src/core/types/id.mts"],"names":[],"mappings":""}

package/dist/core/types/index.mjs

@@ -1,3 +1,7 @@
-import 'ts-data-forge';
-export { isChildObservable, isManagerObservable, isRootObservable } from './observable.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './id.mjs';
+export * from './observable-family.mjs';
+export * from './observable-kind.mjs';
+export * from './observable.mjs';
+export * from './timer.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/core/types/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/core/types/index.mts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC"}

package/dist/core/types/observable-family.mjs

@@ -1,2 +1,14 @@
-import 'ts-data-forge';
-//# sourceMappingURL=observable-family.mjs.map
+
+
+var SynStateInternals;
+(function (SynStateInternals) {
+
+
+
+
+
+
+
+
+})(SynStateInternals || (SynStateInternals = {}));
+//# sourceMappingURL=observable-family.mjs.map

package/dist/core/types/observable-family.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"observable-family.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"observable-family.mjs","sourceRoot":"","sources":["../../../src/core/types/observable-family.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AA6DxD,sBAAsB;AAEtB,IAAU,iBAAiB,CAgG1B;AAhGD,WAAU,iBAAiB;IA0BzB,UAAU,CAAoD,GAAG,CAAC,CAAC;IAEnE,UAAU,CAA8D,GAAG,CAAC,CAAC;IAE7E,UAAU,CAKR,GAAG,CAAC,CAAC;IAEP,UAAU,CAGR,GAAG,CAAC,CAAC;IAEP,UAAU,CAAmD,GAAG,CAAC,CAAC;IAElE,UAAU,CAA6D,GAAG,CAAC,CAAC;IAE5E,UAAU,CAKR,GAAG,CAAC,CAAC;IAEP,UAAU,CAGR,GAAG,CAAC,CAAC;AAwCT,CAAC,EAhGS,iBAAiB,KAAjB,iBAAiB,QAgG1B"}

package/dist/core/types/observable-kind.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=observable-kind.mjs.map
+export {};
+//# sourceMappingURL=observable-kind.mjs.map

package/dist/core/types/observable-kind.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"observable-kind.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"observable-kind.mjs","sourceRoot":"","sources":["../../../src/core/types/observable-kind.mts"],"names":[],"mappings":""}

package/dist/core/types/observable.mjs

@@ -1,8 +1,16 @@
-import 'ts-data-forge';
 
-const isManagerObservable = (obs) => obs.kind !== "sync child";
-const isRootObservable = (obs) => obs.kind === "root";
-const isChildObservable = (obs) => obs.kind === "sync child" || obs.kind === "async child";
+export const isManagerObservable = (obs) => obs.kind !== 'sync child';
+export const isRootObservable = (obs) => obs.kind === 'root';
+export const isChildObservable = (obs) => obs.kind === 'sync child' || obs.kind === 'async child';
 
-export { isChildObservable, isManagerObservable, isRootObservable };
-//# sourceMappingURL=observable.mjs.map
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=observable.mjs.map

package/dist/core/types/observable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"observable.mjs","sources":["../../../src/core/types/observable.mts"],"sourcesContent":["import { expectType, type Optional, type Some } from 'ts-data-forge';\nimport { type FixedLengthTuple, type StrictOmit } from 'ts-type-forge';\nimport { type ObservableId, type UpdateToken } from './id.mjs';\nimport { type ObservableKind } from './observable-kind.mjs';\nimport { type NonEmptyUnknownList, type Subscription } from './types.mjs';\n\n/**\n * Inheritance\n *\n * ```txt\n * ObservableBase\n *   |\n *   +- SyncChildObservable    \\                       \\\n *   |                          +-- ChildObservable     \\\n *   +- AsyncChildObservable   X                         +-- Observable\n *   |                          +-- ManagerObservable   /\n *   +- RootObservableType     /                       /\n * ```\n */\n\ntype CreateObservableType<A, Kind extends ObservableKind> = Readonly<{\n  id: ObservableId;\n  kind: Kind;\n\n  // reactive dependency tree structure\n  depth: ObservableKind extends 'root' ? 0 : number;\n  addChild: <B>(child: ChildObservable<B>) => void;\n\n  // state\n  getSnapshot: () => Optional<A>;\n  isCompleted: boolean;\n  updateToken: UpdateToken;\n  hasSubscriber: boolean;\n  hasChild: boolean;\n  hasActiveChild: () => boolean;\n\n  tryUpdate: (updateToken: UpdateToken) => void;\n  tryComplete: () => void;\n  complete: () => void;\n  subscribe: (onNext: (v: A) => void, onComplete?: () => void) => Subscription;\n\n  pipe: PipeMethod<A>;\n}>;\n\n/** @internal */\ntype PipeMethod<A> = (<B>(\n  operator: WithInitialValueOperator<A, B>,\n) => InitializedObservable<B>) &\n  (<B>(operator: DropInitialValueOperator<A, B>) => Observable<B>) &\n  (<B>(operator: KeepInitialValueOperator<A, B>) => Observable<B>);\n\nexport type ObservableBase<A> = CreateObservableType<A, ObservableKind>;\n\n/** @internal */\nnamespace ObservableTypeConverter {\n  export type ToInitialized<\n    A,\n    O extends CreateObservableType<A, ObservableKind>,\n  > = StrictOmit<O, 'pipe' | 'getSnapshot'> &\n    Readonly<{\n      getSnapshot: () => Some<A>;\n\n      pipe: PipeMethodForInitialized<A>;\n    }>;\n\n  type PipeMethodForInitialized<A> = (<B>(\n    operator: WithInitialValueOperator<A, B>,\n  ) => InitializedObservable<B>) &\n    (<B>(operator: DropInitialValueOperator<A, B>) => Observable<B>) &\n    (<B>(operator: KeepInitialValueOperator<A, B>) => InitializedObservable<B>);\n\n  export type ToChild<\n    A,\n    O extends CreateObservableType<A, ObservableKind>,\n    P extends NonEmptyUnknownList = NonEmptyUnknownList,\n  > = O &\n    Readonly<{\n      parents: Wrap<P>;\n    }>;\n\n  export type ToManager<\n    A,\n    O extends CreateObservableType<A, 'async child' | 'root'>,\n  > = O &\n    Readonly<{\n      addDescendant: <B>(child: ChildObservable<B>) => void;\n    }>;\n}\n\nexport type SyncChildObservable<\n  A,\n  P extends NonEmptyUnknownList = NonEmptyUnknownList,\n> = ObservableTypeConverter.ToChild<\n  A,\n  CreateObservableType<A, 'sync child'>,\n  P\n>;\n\nexport type InitializedSyncChildObservable<\n  A,\n  P extends NonEmptyUnknownList = NonEmptyUnknownList,\n> = ObservableTypeConverter.ToInitialized<A, SyncChildObservable<A, P>>;\n\nexport type AsyncChildObservable<\n  A,\n  P extends NonEmptyUnknownList = NonEmptyUnknownList,\n> = ObservableTypeConverter.ToManager<\n  A,\n  ObservableTypeConverter.ToChild<A, CreateObservableType<A, 'async child'>, P>\n>;\n\nexport type InitializedAsyncChildObservable<\n  A,\n  P extends NonEmptyUnknownList = NonEmptyUnknownList,\n> = ObservableTypeConverter.ToInitialized<A, AsyncChildObservable<A, P>>;\n\nexport type ChildObservable<\n  A,\n  P extends NonEmptyUnknownList = NonEmptyUnknownList,\n> = AsyncChildObservable<A, P> | SyncChildObservable<A, P>;\n\nexport type RootObservable<A> = ObservableTypeConverter.ToManager<\n  A,\n  CreateObservableType<A, 'root'>\n>;\n\nexport type InitializedRootObservable<A> =\n  ObservableTypeConverter.ToInitialized<A, RootObservable<A>>;\n\nexport type Observable<A> =\n  AsyncChildObservable<A> | RootObservable<A> | SyncChildObservable<A>;\n\nexport type InitializedObservable<A> =\n  | InitializedAsyncChildObservable<A>\n  | InitializedRootObservable<A>\n  | InitializedSyncChildObservable<A>;\n\nexport type ManagerObservable<A> = AsyncChildObservable<A> | RootObservable<A>;\n\n/* operator types */\n\n/** Type of operator that converts Observable to InitializedObservable */\nexport type WithInitialValueOperator<A, B> = (\n  src: Observable<A>,\n) => InitializedObservable<B>;\n\n/** Type of operator that converts Observable to non-initialized Observable */\nexport type DropInitialValueOperator<A, B> = (\n  src: InitializedObservable<A> | Observable<A>,\n) => Observable<B>;\n\n/** Type of operator that preserves whether Observable has initial value */\nexport type KeepInitialValueOperator<A, B> = (\n  src: InitializedObservable<A>,\n) => InitializedObservable<B>;\n\nexport type Operator<A, B> =\n  | WithInitialValueOperator<A, B>\n  | DropInitialValueOperator<A, B>\n  | KeepInitialValueOperator<A, B>;\n\nexport const isManagerObservable = <A,>(\n  obs: Observable<A>,\n): obs is ManagerObservable<A> => obs.kind !== 'sync child';\n\nexport const isRootObservable = <A,>(\n  obs: Observable<A>,\n): obs is RootObservable<A> => obs.kind === 'root';\n\nexport const isChildObservable = <A,>(\n  obs: Observable<A>,\n): obs is ChildObservable<A> =>\n  obs.kind === 'sync child' || obs.kind === 'async child';\n\nexport type ObservableValue<A> = A extends Observable<infer B> ? B : never;\n\nexport type Unwrap<A extends readonly Observable<unknown>[]> = Readonly<{\n  [P in keyof A]: ObservableValue<A[P]>;\n}>;\n\nexport type Wrap<A extends readonly unknown[]> = Readonly<{\n  [P in keyof A]: Observable<A[P]>;\n}>;\n\nexport type WrapInitialized<A extends readonly unknown[]> = Readonly<{\n  [P in keyof A]: InitializedObservable<A[P]>;\n}>;\n\n// type GetDestTypeOfOperator<Op extends Operator<unknown, unknown>> =\n//   Op extends Operator<unknown, infer B> ? B : never;\n\nexpectType<keyof AsyncChildObservable<unknown>, 'addDescendant'>('>=');\n\nexpectType<keyof RootObservable<unknown>, 'addDescendant'>('>=');\n\nexpectType<Unwrap<Wrap<readonly [1, 2, 3]>>, readonly [1, 2, 3]>('=');\n\nexpectType<number, ObservableValue<Observable<number>>>('<=');\n\nexpectType<number, ObservableValue<Observable<string>>>('!<=');\n\nexpectType<\n  readonly [number, string],\n  Unwrap<readonly [Observable<number>, Observable<string>]>\n>('<=');\n\nexpectType<number, ObservableValue<Observable<string>>>('!<=');\n\nexpectType<\n  FixedLengthTuple<2, Observable<number>>,\n  Wrap<FixedLengthTuple<2, number>>\n>('<=');\n\nexpectType<\n  readonly [Observable<number>, Observable<string>],\n  Wrap<FixedLengthTuple<2, number>>\n>('!<=');\n"],"names":[],"mappings":";;AAiKO,MAAM,mBAAA,GAAsB,CACjC,GAAA,KACgC,GAAA,CAAI,IAAA,KAAS;AAExC,MAAM,gBAAA,GAAmB,CAC9B,GAAA,KAC6B,GAAA,CAAI,IAAA,KAAS;MAE/B,oBAAoB,CAC/B,GAAA,KAEA,IAAI,IAAA,KAAS,YAAA,IAAgB,IAAI,IAAA,KAAS;;;;"}
+{"version":3,"file":"observable.mjs","sourceRoot":"","sources":["../../../src/core/types/observable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA4B,MAAM,eAAe,CAAC;AAiKrE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,GAAkB,EACW,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,YAAY,CAAC;AAE5D,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,GAAkB,EACQ,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,MAAM,CAAC;AAEnD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,GAAkB,EACS,EAAE,CAC7B,GAAG,CAAC,IAAI,KAAK,YAAY,IAAI,GAAG,CAAC,IAAI,KAAK,aAAa,CAAC;AAgB1D,sEAAsE;AACtE,uDAAuD;AAEvD,UAAU,CAAuD,IAAI,CAAC,CAAC;AAEvE,UAAU,CAAiD,IAAI,CAAC,CAAC;AAEjE,UAAU,CAAuD,GAAG,CAAC,CAAC;AAEtE,UAAU,CAA8C,IAAI,CAAC,CAAC;AAE9D,UAAU,CAA8C,KAAK,CAAC,CAAC;AAE/D,UAAU,CAGR,IAAI,CAAC,CAAC;AAER,UAAU,CAA8C,KAAK,CAAC,CAAC;AAE/D,UAAU,CAGR,IAAI,CAAC,CAAC;AAER,UAAU,CAGR,KAAK,CAAC,CAAC"}

package/dist/core/types/timer.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=timer.mjs.map
+export {};
+//# sourceMappingURL=timer.mjs.map

package/dist/core/types/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"timer.mjs","sourceRoot":"","sources":["../../../src/core/types/timer.mts"],"names":[],"mappings":""}