@rimbu/common 0.9.3 → 0.10.1

package/dist/types/reducer.d.ts

@@ -6,15 +6,6 @@ import { CollectFun, Eq, OptLazy } from './internal';
  */
 export declare type Reducer<I, O = I> = Reducer.Impl<I, O, unknown>;
 export declare namespace Reducer {
-    /**
-     * Ensures that all non-primitive type use lazy initialization to prevent accidental instance sharing.
-     */
-    type Init<T> = T extends object | (() => any) ? () => T : T;
-    /**
-     * Returns the contained value for an `Init` instance.
-     * @param init - the `Init` value container
-     */
-    function Init<T>(init: Reducer.Init<T>): T;
     /**
      * The Implementation interface for a `Reducer`, which also exposes the internal state type.
      * @typeparam I - the input value type
@@ -25,7 +16,7 @@ export declare namespace Reducer {
         /**
          * The initial state value for the reducer algorithm.
          */
-        readonly init: Reducer.Init<S>;
+        readonly init: OptLazy<S>;
         /**
          * Returns the next state based on the given input values
          * @param state - the current state
@@ -54,6 +45,7 @@ export declare namespace Reducer {
         filterInput(pred: (value: I, index: number, halt: () => void) => boolean): Reducer<I, O>;
         /**
          * Returns a `Reducer` instance that converts its input values using given `mapFun` before passing them to the reducer.
+         * @typeparam I2 - the resulting reducer input type
          * @param mapFun - a function that returns a new value to pass to the reducer based on the following inputs:<br/>
          * - value: the current input value<br/>
          * - index: the current input index
@@ -66,6 +58,7 @@ export declare namespace Reducer {
         mapInput<I2>(mapFun: (value: I2, index: number) => I): Reducer<I2, O>;
         /**
          * Returns a `Reducer` instance that converts or filters its input values using given `collectFun` before passing them to the reducer.
+         * @typeparam I2 - the resulting reducer input type
          * @param collectFun - a function receiving<br/>
          * - `value`: the next value<br/>
          * - `index`: the value index<br/>
@@ -81,6 +74,7 @@ export declare namespace Reducer {
         collectInput<I2>(collectFun: CollectFun<I2, I>): Reducer<I2, O>;
         /**
          * Returns a `Reducer` instance that converts its output values using given `mapFun`.
+         * @typeparam O2 - the resulting reducer output type
          * @param mapFun - a function that takes the current output value and converts it to a new output value
          * @example
          * ```ts
@@ -128,10 +122,10 @@ export declare namespace Reducer {
      * @typeparam S - the internal state type
      */
     class Base<I, O, S> implements Reducer.Impl<I, O, S> {
-        readonly init: Reducer.Init<S>;
+        readonly init: OptLazy<S>;
         readonly next: (state: S, elem: I, index: number, halt: () => void) => S;
         readonly stateToResult: (state: S) => O;
-        constructor(init: Reducer.Init<S>, next: (state: S, elem: I, index: number, halt: () => void) => S, stateToResult: (state: S) => O);
+        constructor(init: OptLazy<S>, next: (state: S, elem: I, index: number, halt: () => void) => S, stateToResult: (state: S) => O);
         filterInput(pred: (value: I, index: number, halt: () => void) => boolean): Reducer<I, O>;
         mapInput<I2>(mapFun: (value: I2, index: number) => I): Reducer<I2, O>;
         collectInput<I2>(collectFun: CollectFun<I2, I>): Reducer<I2, O>;
@@ -164,7 +158,7 @@ export declare namespace Reducer {
      * // => 'even'
      * ```
      */
-    function create<I, O = I, S = O>(init: Reducer.Init<S>, next: (current: S, next: I, index: number, halt: () => void) => S, stateToResult: (state: S) => O): Reducer<I, O>;
+    function create<I, O = I, S = O>(init: OptLazy<S>, next: (current: S, next: I, index: number, halt: () => void) => S, stateToResult: (state: S) => O): Reducer<I, O>;
     /**
      * Returns a `Reducer` of which the input, state, and output types are the same.
      * @param init - the initial state value
@@ -187,7 +181,7 @@ export declare namespace Reducer {
      * // => 9
      * ```
      */
-    function createMono<T>(init: Reducer.Init<T>, next: (current: T, next: T, index: number, halt: () => void) => T, stateToResult?: (state: T) => T): Reducer<T>;
+    function createMono<T>(init: OptLazy<T>, next: (current: T, next: T, index: number, halt: () => void) => T, stateToResult?: (state: T) => T): Reducer<T>;
     /**
      * Returns a `Reducer` of which the state and output types are the same.
      * @param init - the initial state value
@@ -211,7 +205,7 @@ export declare namespace Reducer {
      * // => 'TFT'
      * ```
      */
-    function createOutput<I, O = I>(init: Reducer.Init<O>, next: (current: O, next: I, index: number, halt: () => void) => O, stateToResult?: (state: O) => O): Reducer<I, O>;
+    function createOutput<I, O = I>(init: OptLazy<O>, next: (current: O, next: I, index: number, halt: () => void) => O, stateToResult?: (state: O) => O): Reducer<I, O>;
     /**
      * A `Reducer` that sums all given numeric input values.
      * @example
@@ -385,8 +379,8 @@ export declare namespace Reducer {
      * @typeparam O - the fallback value type
      * @example
      * ```ts
-     * console.log(Stream.range{ amount: 10 }).reduce(Reducer.first())
-     * // => 0
+     * console.log(Stream.range{ amount: 10 }).reduce(Reducer.last())
+     * // => 9
      * ```
      */
     const last: {
@@ -395,6 +389,7 @@ export declare namespace Reducer {
     };
     /**
      * Returns a `Reducer` that ouputs false as long as no input value satisfies given `pred`, true otherwise.
+     * @typeparam T - the element type
      * @param pred - a function taking an input value and its index, and returning true if the value satisfies the predicate
      * @example
      * ```ts
@@ -405,6 +400,7 @@ export declare namespace Reducer {
     function some<T>(pred: (value: T, index: number) => boolean): Reducer<T, boolean>;
     /**
      * Returns a `Reducer` that ouputs true as long as all input values satisfy the given `pred`, false otherwise.
+     * @typeparam T - the element type
      * @param pred - a function taking an input value and its index, and returning true if the value satisfies the predicate
      * @example
      * ```ts
@@ -415,6 +411,7 @@ export declare namespace Reducer {
     function every<T>(pred: (value: T, index: number) => boolean): Reducer<T, boolean>;
     /**
      * Returns a `Reducer` that outputs false as long as the given `elem` has not been encountered in the input values, true otherwise.
+     * @typeparam T - the element type
      * @param elem - the element to search for
      * @param eq - (optional) a comparison function that returns true if te two given input values are considered equal
      * @example
@@ -462,6 +459,7 @@ export declare namespace Reducer {
     const nonEmpty: Reducer<any, boolean>;
     /**
      * Returns a `Reducer` that collects received input values in an array, and returns a copy of that array as an output value when requested.
+     * @typeparam T - the element type
      * @example
      * ```ts
      * console.log(Stream.of(1, 2, 3).reduce(Reducer.toArray()))
@@ -472,6 +470,8 @@ export declare namespace Reducer {
     /**
      * Returns a `Reducer` that collects received input tuples into a mutable JS Map, and returns
      * a copy of that map when output is requested.
+     * @typeparam K - the map key type
+     * @typeparam V - the map value type
      * @example
      * ```ts
      * console.log(Stream.of([1, 'a'], [2, 'b']).reduce(Reducer.toJSMap()))
@@ -482,6 +482,7 @@ export declare namespace Reducer {
     /**
      * Returns a `Reducer` that collects received input values into a mutable JS Set, and returns
      * a copy of that map when output is requested.
+     * @typeparam T - the element type
      * @example
      * ```ts
      * console.log(Stream.of(1, 2, 3).reduce(Reducer.toJSSet()))
@@ -489,6 +490,21 @@ export declare namespace Reducer {
      * ```
      */
     function toJSSet<T>(): Reducer<T, Set<T>>;
+    /**
+     * Returns a `Reducer` that collects 2-tuples containing keys and values into a plain JS object, and
+     * returns a copy of that object when output is requested.
+     * @typeparam K - the result object key type
+     * @typeparam V - the result object value type
+     * @example
+     * ```ts
+     * console.log(Stream.of(['a', 1], ['b', true]).reduce(Reducer.toJSObject()))
+     * // { a: 1, b: true }
+     * ```
+     */
+    function toJSObject<K extends string | number | symbol, V>(): Reducer<[
+        K,
+        V
+    ], Record<K, V>>;
     /**
      * Returns a `Reducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in an array.
      * @param reducers - 2 or more reducers to combine

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/common",
-  "version": "0.9.3",
+  "version": "0.10.1",
   "description": "Common types and objects used in many other Rimbu packages",
   "keywords": [
     "common",
@@ -60,8 +60,5 @@
     "index": "src/index.ts",
     "replacer": "../../config/denoify-rimbu-replacer.js"
   },
-  "dependencies": {
-    "tslib": "^2.4.0"
-  },
-  "gitHead": "4efaf8c469d606381517984436383fd6b1b61ec0"
+  "gitHead": "9e7cd56ce066f7903c5749110c2a7a8b06809403"
 }