synstate 3.0.0 → 3.0.2

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

@@ -1,9 +1,57 @@
-import 'ts-data-forge';
-import '../../utils/id-maker.mjs';
-import { map } from '../../operators/map.mjs';
+import { map } from '../../operators/index.mjs';
 
-const withIndex = () => map((a, i) => [i, a]);
-const attachIndex = withIndex;
 
-export { attachIndex, withIndex };
-//# sourceMappingURL=attach-index.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const withIndex = () => map((a, i) => [i, a]);
+
+
+
+
+export const attachIndex = withIndex;
+//# sourceMappingURL=attach-index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"attach-index.mjs","sources":["../../../../src/core/predefined/operators/attach-index.mts"],"sourcesContent":["import { type SafeUint } from 'ts-type-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Attaches a sequential index to each emitted value, producing `[index, value]` tuples.\n * Index starts at 0 and increments with each emission.\n *\n * @template A - The type of values from the source\n * @returns An operator that emits `[index, value]` tuples\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  letter$    \"A\"      \"B\"      \"C\"\n * //  indexed$   [0,\"A\"]  [1,\"B\"]  [2,\"C\"]\n * //\n * //  Explanation:\n * //  - attachIndex attaches a sequential index to each emitted value\n * //  - Produces [index, value] tuples\n * //  - Index starts at 0 and increments with each emission\n *\n * const letter$ = source<string>();\n *\n * const indexed$ = letter$.pipe(attachIndex());\n *\n * const valueHistory: (readonly [number, string])[] = [];\n *\n * indexed$.subscribe(([i, letter]) => {\n *   valueHistory.push([i, letter]);\n * });\n *\n * letter$.next('A');\n *\n * assert.deepStrictEqual(valueHistory, [[0, 'A']]);\n *\n * letter$.next('B');\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [0, 'A'],\n *   [1, 'B'],\n * ]);\n *\n * letter$.next('C');\n *\n * assert.deepStrictEqual(valueHistory, [\n *   [0, 'A'],\n *   [1, 'B'],\n *   [2, 'C'],\n * ]);\n * ```\n */\nexport const withIndex = <A,>(): KeepInitialValueOperator<\n  A,\n  readonly [SafeUint | -1, A]\n> => map((a, i) => [i, a] as const);\n\n/**\n * Alias for `withIndex`.\n * @see withIndex\n */\nexport const attachIndex = withIndex;\n"],"names":[],"mappings":";;;;AAqDO,MAAM,SAAA,GAAY,MAGpB,GAAA,CAAI,CAAC,GAAG,CAAA,KAAM,CAAC,CAAA,EAAG,CAAC,CAAU;AAM3B,MAAM,WAAA,GAAc;;;;"}
+{"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"}

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

@@ -1,12 +1,12 @@
-export { attachIndex, withIndex } from './attach-index.mjs';
-export { mapOptional } from './map-optional.mjs';
-export { mapResultErr } from './map-result-err.mjs';
-export { mapResultOk } from './map-result-ok.mjs';
-export { mapTo } from './map-to.mjs';
-export { getKey, pluck } from './pluck.mjs';
-export { skip } from './skip.mjs';
-export { take } from './take.mjs';
-export { unwrapOptional } from './unwrap-optional.mjs';
-export { unwrapResultErr } from './unwrap-result-err.mjs';
-export { unwrapResultOk } from './unwrap-result-ok.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './attach-index.mjs';
+export * from './map-optional.mjs';
+export * from './map-result-err.mjs';
+export * from './map-result-ok.mjs';
+export * from './map-to.mjs';
+export * from './pluck.mjs';
+export * from './skip.mjs';
+export * from './take.mjs';
+export * from './unwrap-optional.mjs';
+export * from './unwrap-result-err.mjs';
+export * from './unwrap-result-ok.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"map-optional.mjs","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"sourcesContent":["import { Optional, type UnknownOptional } from 'ts-data-forge';\nimport { map } from '../../operators/index.mjs';\nimport { type KeepInitialValueOperator } from '../../types/index.mjs';\n\n/**\n * Transforms the inner value of an `Optional` type emitted by the source.\n * If the value is `Some`, the mapping function is applied; if `None`, it remains `None`.\n *\n * @template O - The Optional type from the source\n * @template B - The type of the mapped inner value\n * @param mapFn - A function to transform the unwrapped value\n * @returns An operator that maps the inner value of Optional emissions\n *\n * @example\n * ```ts\n * //  Timeline:\n * //\n * //  value$    Some(2)    None       Some(5)\n * //  doubled$  Some(4)    None       Some(10)\n * //\n * //  Explanation:\n * //  - mapOptional transforms the inner value of Optional emissions\n * //  - Some values are mapped; None values pass through unchanged\n *\n * const value$ = source<Optional<number>>();\n *\n * const doubled$ = value$.pipe(mapOptional((x) => x * 2));\n *\n * const valueHistory: Optional<number>[] = [];\n *\n * doubled$.subscribe((v) => {\n *   valueHistory.push(v);\n * });\n *\n * value$.next(Optional.some(2));\n *\n * assert.deepStrictEqual(valueHistory, [Optional.some(4)]);\n *\n * value$.next(Optional.none);\n *\n * assert.deepStrictEqual(valueHistory, [Optional.some(4), Optional.none]);\n *\n * value$.next(Optional.some(5));\n *\n * assert.deepStrictEqual(valueHistory, [\n *   Optional.some(4),\n *   Optional.none,\n *   Optional.some(10),\n * ]);\n * ```\n */\nexport const mapOptional = <O extends UnknownOptional, B>(\n  mapFn: (x: Optional.Unwrap<O>) => B,\n): KeepInitialValueOperator<O, Optional<B>> => map(Optional.map(mapFn));\n"],"names":[],"mappings":";;;;AAmDO,MAAM,cAAc,CACzB,KAAA,KAC6C,IAAI,QAAA,CAAS,GAAA,CAAI,KAAK,CAAC;;;;"}
+{"version":3,"file":"map-optional.mjs","sourceRoot":"","sources":["../../../../src/core/predefined/operators/map-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC;AAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,KAAmC,EACO,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC"}

package/dist/core/predefined/operators/map-result-err.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 mapResultErr = (mapFn) => map(Result.mapErr(mapFn));
 
-export { mapResultErr };
-//# sourceMappingURL=map-result-err.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const mapResultErr = (mapFn) => map(Result.mapErr(mapFn));
+//# sourceMappingURL=map-result-err.mjs.map

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