@rimbu/stream
Version:
Efficient structure representing a sequence of elements, with powerful operations for TypeScript
298 lines • 14.8 kB
JavaScript
import { CollectFun, Eq } from '@rimbu/common';
import { Reducer, Stream } from '@rimbu/stream';
export var Transformer;
(function (Transformer) {
/**
* Returns a transformer that produces windows/collections of `windowSize` size, each
* window starting `skipAmount` of elements after the previous, and optionally collected
* by a custom reducer.
* @typeparam T - the input element type
* @typeparam R - the window type
* @param windowSize - the amount of elements for each window
* @param options - (optional) object specifying the following properties<br/>
* - skipAmount - (default: `windowSize`) the amount of elements between the start of each window
* - collector - (default: Reducer.toArray()) the reducer to use to convert elements to windows
* @example
* ```ts
* Stream.of(1, 2, 3, 4, 5, 6)
* .transform(Transformer.window(3))
* .toArray()
* // => [[1, 2, 3], [4, 5, 6]]
* ```
*/
Transformer.window = (windowSize, options = {}) => {
const { skipAmount = windowSize, collector = Reducer.toArray(), } = options;
return Reducer.create(() => new Set(), (state, elem, index) => {
for (const instance of state) {
if (instance.index >= windowSize || instance.halted) {
state.delete(instance);
}
else {
instance.next(elem);
}
}
if (index % skipAmount === 0) {
const newInstance = collector.compile();
newInstance.next(elem);
state.add(newInstance);
}
return state;
}, (state, _, halted) => {
if (halted) {
return Stream.empty();
}
return Stream.from(state).collect((instance, _, skip) => instance.index === windowSize ? instance.getOutput() : skip);
});
};
/**
* Returns a transformer that returns only those elements from the input that are different to previous element
* according to the optionally given `eq` function.
* @param options:
* - eq - (default: `Eq.objectIs`) the equality testing function
* - negate: (default: false) when true will negate the given predicate<br/>
* @example
* ```ts
* Stream.of(1, 1, 2, 3, 2, 2)
* .transform(Transformer.distinctPrevious())
* .toArray()
* // => [1, 2, 3, 2]
* ```
*/
function distinctPrevious(options = {}) {
const { eq = Eq.objectIs, negate = false } = options;
const token = Symbol();
return Reducer.create(() => token, (state, next) => token === state || eq(state, next) === negate ? next : token, (state, _, halted) => halted || token === state ? Stream.empty() : Stream.of(state));
}
Transformer.distinctPrevious = distinctPrevious;
/**
* Returns a transformer that applies the given flatMap function to each element of the input stream,
* and concatenates all the resulting resulting streams into one stream.
* @typeparam T - the input element type
* @typeparam T2 - the output element type
* @param flatMapFun - a function that maps each input element to an `StreamSource` or a promise
* resolving to a `StreamSource`. The function receives three parameters:<br/>
* - `value`: the current element being processed<br/>
* - `index`: the index of the current element in the input stream<br/>
* - `halt`: a function that can be called to halt further processing of the input stream<br/>
*/
function flatMap(flatMapFun) {
return Reducer.createOutput(() => Stream.empty(), (state, next, index, halt) => flatMapFun(next, index, halt), (state, _, halted) => (halted ? Stream.empty() : state));
}
Transformer.flatMap = flatMap;
/**
* Returns a transformer that applies the given flatMap function to each element of the input stream,
* and concatenates all the resulting resulting streams into one stream, where each resulting element is tupled
* with the originating input element.
* @typeparam T - the input element type
* @typeparam T2 - the output element type
* @param flatMapFun - a function that maps each input element to an `StreamSource` or a promise
* resolving to an `StreamSource`. The function receives three parameters:<br/>
* - `value`: the current element being processed<br/>
* - `index`: the index of the current element in the input stream<br/>
* - `halt`: a function that can be called to halt further processing of the input stream<br/>
*/
function flatZip(flatMapFun) {
return flatMap((value, index, halt) => Stream.from(flatMapFun(value, index, halt)).mapPure((stream) => [
value,
stream,
]));
}
Transformer.flatZip = flatZip;
/**
* Returns a transformer that filters elements from the input stream based on the provided predicate function.
* @typeparam T - the type of elements in the input stream
* @param pred - a predicate function that determines whether an element should be included in the output stream, receiving:<br/>
* - `value`: the current element being processed<br/>
* - `index`: the index of the current element in the input stream<br/>
* - `halt`: a function that can be called to halt further processing of the input stream
* @param options - (optional) object specifying the following properties:<br/>
* - negate: (default: false) if true, the predicate will be negated
* @note if the predicate is a type guard, the return type is automatically inferred
*/
Transformer.filter = (pred, options = {}) => {
const { negate = false } = options;
return flatMap((value, index, halt) => pred(value, index, halt) !== negate ? Stream.of(value) : Stream.empty());
};
/**
* Returns a `Transformer` instance that converts or filters its input values using given `collectFun` before passing them to the reducer.
* @param collectFun - a function receiving the following arguments, and returns a new value or `skip` if the value should be skipped:<br/>
* - `value`: the next value<br/>
* - `index`: the value index<br/>
* - `skip`: a token that, when returned, will not add a value to the resulting collection<br/>
* - `halt`: a function that, when called, ensures no next elements are passed
* @typeparam T - the input element type
* @typeparam R - the result element type
*/
function collect(collectFun) {
return flatMap((value, index, halt) => {
const result = collectFun(value, index, CollectFun.Skip, halt);
return CollectFun.Skip === result ? Stream.empty() : Stream.of(result);
});
}
Transformer.collect = collect;
/**
* Returns a `Transfoemr` that inserts the given `sep` stream source elements between each received input element.
* @param sep - the StreamSource to insert between each received element
* @typeparam T - the input and output element type
*/
function intersperse(sep) {
return flatMap((value, index) => index === 0 ? Stream.of(value) : Stream.from(sep).append(value));
}
Transformer.intersperse = intersperse;
/**
* Returns a `Transformer` that outputs the index of each received element that satisfies the given predicate.
* @param pred - a predicate function taking an element
* @param options - (optional) object specifying the following properties<br/>
* - negate: (default: false) when true will negate the given predicate
* @typeparam T - the input element type
*/
function indicesWhere(pred, options = {}) {
const { negate = false } = options;
return flatMap((value, index) => pred(value) !== negate ? Stream.of(index) : Stream.empty());
}
Transformer.indicesWhere = indicesWhere;
/**
* Returns a `Transformer` that outputs the index of each received element that is equal to the given `searchValue` value,
* according to the `eq` equality function.
* @param searchValue - the value to match input values to
* @param options - (optional) object specifying the following properties<br/>
* - eq - (default: `Eq.objectIs`) the equality testing function
* - negate: (default: false) when true will negate the given predicate
* @typeparam T - the input element type
*/
function indicesOf(searchValue, options = {}) {
const { eq = Eq.objectIs, negate = false } = options;
return flatMap((value, index) => eq(value, searchValue) !== negate ? Stream.of(index) : Stream.empty());
}
Transformer.indicesOf = indicesOf;
/**
* Returns a `Transformer` that applies the given `pred` function to each received element, and collects the received elements
* into a `collector` that will be returned as output every time the predicate returns true.
* @typeparam T - the input element type
* @typeparam R - the collector result type
* @param pred - a predicate function taking an element
* @param options - (optional) object specifying the following properties<br/>
* - negate: (default: false) when true will negate the given predicate<br/>
* - collector: (default: Reducer.toArray()) a Reducer that can accept multiple values and reduce them into a single value of type `R`.
*/
function splitWhere(pred, options = {}) {
const { negate = false, collector = Reducer.toArray() } = options;
return Reducer.create(() => ({ collection: collector.compile(), done: false }), (state, nextValue, index) => {
if (state.done) {
state.done = false;
state.collection = collector.compile();
}
if (pred(nextValue, index) === negate) {
state.collection.next(nextValue);
}
else {
state.done = true;
}
return state;
}, (state, _, halted) => state.done !== halted
? Stream.of(state.collection.getOutput())
: Stream.empty());
}
Transformer.splitWhere = splitWhere;
/**
* Returns a `Transformer` that collects the received elements
* into a `collector` that will be returned as output every time the input matches the given `sepElem` value.
* @typeparam T - the input element type
* @typeparam R - the collector result type
* @param pred - a predicate function taking an element
* @param options - (optional) object specifying the following properties<br/>
* - eq - (default: `Eq.objectIs`) the equality testing function
* - negate: (default: false) when true will negate the given predicate<br/>
* - collector: (default: Reducer.toArray()) an AsyncReducer that can accept multiple values and reduce them into a single value of type `R`.
*/
function splitOn(sepElem, options = {}) {
const { eq = Eq.objectIs, negate = false, collector = Reducer.toArray(), } = options;
return Reducer.create(() => ({ collection: collector.compile(), done: false }), (state, nextValue) => {
if (state.done) {
state.done = false;
state.collection = collector.compile();
}
if (eq(nextValue, sepElem) === negate) {
state.collection.next(nextValue);
}
else {
state.done = true;
}
return state;
}, (state, _, halted) => state.done !== halted
? Stream.of(state.collection.getOutput())
: Stream.empty());
}
Transformer.splitOn = splitOn;
/**
* Returns a `Transformer` that collects the received elements
* into a `collector` that will be returned as output every time the input matches the given `sepSlice` sequence of elements.
* @typeparam T - the input element type
* @typeparam R - the collector result type
* @param pred - a predicate function taking an element
* @param options - (optional) object specifying the following properties<br/>
* - eq - (default: `Eq.objectIs`) the equality testing function
* - collector: (default: Reducer.toArray()) an AsyncReducer that can accept multiple values and reduce them into a single value of type `R`.
*/
function splitOnSlice(sepSlice, options = {}) {
const { eq = Eq.objectIs, collector = Reducer.toArray() } = options;
return Reducer.create(() => ({
done: false,
instances: new Map(),
buffer: [],
result: collector.compile(),
}), (state, nextValue) => {
if (state.done) {
state.result = collector.compile();
state.done = false;
}
for (const [instance, startIndex] of state.instances) {
instance.next(nextValue);
if (instance.halted) {
state.instances.delete(instance);
}
if (instance.getOutput()) {
state.done = true;
Stream.fromArray(state.buffer, {
range: { end: [startIndex, false] },
}).forEachPure(state.result.next);
state.buffer = [];
state.instances.clear();
return state;
}
}
const nextStartsWith = Reducer.startsWithSlice(sepSlice, {
eq,
}).compile();
nextStartsWith.next(nextValue);
if (nextStartsWith.getOutput()) {
state.done = true;
Stream.fromArray(state.buffer).forEachPure(state.result.next);
state.buffer = [];
state.instances.clear();
return state;
}
else if (!nextStartsWith.halted) {
state.instances.set(nextStartsWith, state.buffer.length);
}
if (state.instances.size === 0) {
state.result.next(nextValue);
}
else {
state.buffer.push(nextValue);
}
return state;
}, (state, _, halted) => {
if (state.done === halted) {
return Stream.empty();
}
if (halted) {
Stream.fromArray(state.buffer).forEachPure(state.result.next);
state.buffer = [];
}
return Stream.of(state.result.getOutput());
});
}
Transformer.splitOnSlice = splitOnSlice;
})(Transformer || (Transformer = {}));
//# sourceMappingURL=transformer.mjs.map