Socket
Socket
Sign inDemoInstall

gensequence

Package Overview
Dependencies
0
Maintainers
1
Versions
30
Alerts
File Explorer

Advanced tools

npm Scripts
License

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 3.1.0 to 3.1.1

operators.js

2

dist/operators/operators.d.ts

@@ -1,2 +0,2 @@

import { Maybe, IterableLike, ChainFunction, ReduceFunction, ThenArg, ReduceAsyncFunction, ReduceAsyncFunctionForAsyncIterator } from '../types';
import { ChainFunction, IterableLike, Maybe, ReduceAsyncFunction, ReduceAsyncFunctionForAsyncIterator, ReduceFunction, ThenArg } from '../types';
/**

@@ -3,0 +3,0 @@ * Operators used by Sequence

30

dist/operators/operators.js

@@ -9,11 +9,11 @@ "use strict";

function filter(fnFilter) {
return (i) => op.filter(fnFilter, i);
return (i) => op.filter(i, fnFilter);
}
exports.filter = filter;
function skip(n) {
return (i) => op.skip(n, i);
return (i) => op.skip(i, n);
}
exports.skip = skip;
function take(n) {
return (i) => op.take(n, i);
return (i) => op.take(i, n);
}

@@ -30,3 +30,3 @@ exports.take = take;

function concatMap(fn) {
return (i) => op.concatMap(fn, i);
return (i) => op.concatMap(i, fn);
}

@@ -39,3 +39,3 @@ exports.concatMap = concatMap;

function combine(fnMap, j) {
return (i) => op.combine(fnMap, i, j);
return (i) => op.combine(i, j, fnMap);
}

@@ -47,3 +47,3 @@ exports.combine = combine;

function map(fnMap) {
return (i) => op.map(fnMap, i);
return (i) => op.map(i, fnMap);
}

@@ -57,7 +57,7 @@ exports.map = map;

function all(fn) {
return (i) => op.all(fn, i);
return (i) => op.all(i, fn);
}
exports.all = all;
function any(fn) {
return (i) => op.any(fn, i);
return (i) => op.any(i, fn);
}

@@ -70,27 +70,27 @@ exports.any = any;

function first(fn, defaultValue) {
return (i) => op.first(fn, defaultValue, i);
return (i) => op.first(i, fn, defaultValue);
}
exports.first = first;
function forEach(fn) {
return (i) => op.forEach(fn, i);
return (i) => op.forEach(i, fn);
}
exports.forEach = forEach;
function max(selector) {
return (i) => op.max(selector, i);
return (i) => op.max(i, selector);
}
exports.max = max;
function min(selector) {
return (i) => op.min(selector, i);
return (i) => op.min(i, selector);
}
exports.min = min;
function reduce(fnReduce, initialValue) {
return (i) => op.reduce(fnReduce, initialValue, i);
return (i) => op.reduce(i, fnReduce, initialValue);
}
exports.reduce = reduce;
function reduceAsync(fnReduceAsync, initialValue) {
return (i) => op.reduceAsync(fnReduceAsync, i, initialValue);
return (i) => op.reduceAsync(i, fnReduceAsync, initialValue);
}
exports.reduceAsync = reduceAsync;
function reduceAsyncForAsyncIterator(fnReduceAsync, initialValue) {
return (i) => op.reduceAsyncForAsyncIterator(fnReduceAsync, i, initialValue);
return (i) => op.reduceAsyncForAsyncIterator(i, fnReduceAsync, initialValue);
}

@@ -97,0 +97,0 @@ exports.reduceAsyncForAsyncIterator = reduceAsyncForAsyncIterator;

45

dist/operators/operatorsBase.d.ts

@@ -5,5 +5,5 @@ import { Maybe, IterableLike, AsyncIterableLike, IterableOfPromise } from '../types';

*/
export declare function filter<T>(fnFilter: (t: T) => boolean, i: IterableLike<T>): IterableIterator<T>;
export declare function skip<T>(n: number, i: IterableLike<T>): IterableIterator<T>;
export declare function take<T>(n: number, i: IterableLike<T>): IterableIterator<T>;
export declare function filter<T>(i: IterableLike<T>, fnFilter: (t: T) => boolean): IterableIterator<T>;
export declare function skip<T>(i: IterableLike<T>, n: number): IterableIterator<T>;
export declare function take<T>(i: IterableLike<T>, n: number): IterableIterator<T>;
/**

@@ -13,32 +13,31 @@ * Concat two iterables together

export declare function concat<T>(i: IterableLike<T>, j: IterableLike<T>): IterableIterator<T>;
export declare function concatMap<T, U>(fn: (t: T) => IterableLike<U>, i: IterableLike<T>): IterableIterator<U>;
export declare function concatMap<T, U>(i: IterableLike<T>, fn: (t: T) => IterableLike<U>): IterableIterator<U>;
/**
* Combine two iterables together using fnMap function.
*/
export declare function combine<T, U, V>(fnMap: (t: T, u?: U) => V, i: IterableLike<T>, j: IterableLike<U>): IterableIterator<V>;
export declare function combine<T, U, V>(i: IterableLike<T>, j: IterableLike<U>, fnMap: (t: T, u?: U) => V): IterableIterator<V>;
/**
* apply a mapping function to an Iterable.
*/
export declare function map<T, U>(fnMap: (t: T) => U): (i: IterableLike<T>) => IterableIterator<U>;
export declare function map<T, U>(fnMap: (t: T) => U, i: IterableLike<T>): IterableIterator<U>;
export declare function map<T, U>(i: IterableLike<T>, fnMap: (t: T) => U): IterableIterator<U>;
export declare function scan<T>(i: IterableLike<T>, fnReduce: (prevValue: T, curValue: T, curIndex: number) => T): IterableIterator<T>;
export declare function scan<T>(i: IterableLike<T>, fnReduce: (prevValue: T, curValue: T, curIndex: number) => T, initValue: T): IterableIterator<T>;
export declare function scan<T, U>(i: IterableLike<T>, fnReduce: (prevValue: U, curValue: T, curIndex: number) => U, initValue: U): IterableIterator<U>;
export declare function all<T>(fn: (t: T) => boolean, i: IterableLike<T>): boolean;
export declare function any<T>(fn: (t: T) => boolean, i: IterableLike<T>): boolean;
export declare function all<T>(i: IterableLike<T>, fn: (t: T) => boolean): boolean;
export declare function any<T>(i: IterableLike<T>, fn: (t: T) => boolean): boolean;
export declare function count<T>(i: IterableLike<T>): number;
export declare function first<T>(fn: Maybe<(t: T) => boolean>, defaultValue: Maybe<T>, i: IterableLike<T>): Maybe<T>;
export declare function first<T>(fn: (t: T) => boolean, defaultValue: T, i: IterableLike<T>): T;
export declare function forEach<T>(fn: (t: T, index: number) => void, i: IterableLike<T>): void;
export declare function max<T, U>(selector: undefined, i: IterableLike<T>): Maybe<T>;
export declare function max<T, U>(selector: ((t: T) => U) | undefined, i: IterableLike<T>): Maybe<T>;
export declare function min<T>(selector: undefined, i: IterableLike<T>): Maybe<T>;
export declare function min<T, U>(selector: ((t: T) => U) | undefined, i: IterableLike<T>): Maybe<T>;
export declare function reduce<T, U>(fnReduce: (prevValue: U, curValue: T, curIndex: number) => U, initialValue: U, i: IterableLike<T>): U;
export declare function reduce<T>(fnReduce: (prevValue: T, curValue: T, curIndex: number) => T, initialValue: T, i: IterableLike<T>): T;
export declare function reduce<T>(fnReduce: (prevValue: T, curValue: T, curIndex: number) => T, initialValue: Maybe<T>, i: IterableLike<T>): Maybe<T>;
export declare function reduceAsync<T, U>(fnReduce: (previousValue: U, currentValue: T, currentIndex: number) => U | Promise<U>, i: IterableOfPromise<T>, initialValue: U | Promise<U>): Promise<U>;
export declare function reduceAsync<T>(fnReduce: (previousValue: T, currentValue: T, currentIndex: number) => T | Promise<T>, i: IterableOfPromise<T>, initialValue?: T | Promise<T>): Promise<T>;
export declare function reduceAsyncForAsyncIterator<T, U>(fnReduce: (previousValue: U, currentValue: T, currentIndex: number) => U | Promise<U>, i: AsyncIterableLike<T>, initialValue?: U | Promise<U>): Promise<U>;
export declare function reduceAsyncForAsyncIterator<T>(fnReduce: (previousValue: T, currentValue: T, currentIndex: number) => T | Promise<T>, i: AsyncIterableLike<T>, initialValue?: T | Promise<T>): Promise<T>;
export declare function first<T>(i: IterableLike<T>, fn: Maybe<(t: T) => boolean>, defaultValue: Maybe<T>): Maybe<T>;
export declare function first<T>(i: IterableLike<T>, fn: (t: T) => boolean, defaultValue: T): T;
export declare function forEach<T>(i: IterableLike<T>, fn: (t: T, index: number) => void): void;
export declare function max<T, U>(i: IterableLike<T>, selector: undefined): Maybe<T>;
export declare function max<T, U>(i: IterableLike<T>, selector: ((t: T) => U) | undefined): Maybe<T>;
export declare function min<T>(i: IterableLike<T>, selector: undefined): Maybe<T>;
export declare function min<T, U>(i: IterableLike<T>, selector: ((t: T) => U) | undefined): Maybe<T>;
export declare function reduce<T, U>(i: IterableLike<T>, fnReduce: (prevValue: U, curValue: T, curIndex: number) => U, initialValue: U): U;
export declare function reduce<T>(i: IterableLike<T>, fnReduce: (prevValue: T, curValue: T, curIndex: number) => T, initialValue: T): T;
export declare function reduce<T>(i: IterableLike<T>, fnReduce: (prevValue: T, curValue: T, curIndex: number) => T, initialValue: Maybe<T>): Maybe<T>;
export declare function reduceAsync<T, U>(i: IterableOfPromise<T>, fnReduce: (previousValue: U, currentValue: T, currentIndex: number) => U | Promise<U>, initialValue: U | Promise<U>): Promise<U>;
export declare function reduceAsync<T>(i: IterableOfPromise<T>, fnReduce: (previousValue: T, currentValue: T, currentIndex: number) => T | Promise<T>, initialValue?: T | Promise<T>): Promise<T>;
export declare function reduceAsyncForAsyncIterator<T, U>(i: AsyncIterableLike<T>, fnReduce: (previousValue: U, currentValue: T, currentIndex: number) => U | Promise<U>, initialValue?: U | Promise<U>): Promise<U>;
export declare function reduceAsyncForAsyncIterator<T>(i: AsyncIterableLike<T>, fnReduce: (previousValue: T, currentValue: T, currentIndex: number) => T | Promise<T>, initialValue?: T | Promise<T>): Promise<T>;
/**

@@ -45,0 +44,0 @@ * Convert an Iterator into an IterableIterator

48

dist/operators/operatorsBase.js

@@ -40,3 +40,3 @@ "use strict";

//// Filters
function* filter(fnFilter, i) {
function* filter(i, fnFilter) {
for (const v of i) {

@@ -49,3 +49,3 @@ if (fnFilter(v)) {

exports.filter = filter;
function* skip(n, i) {
function* skip(i, n) {
let a = 0;

@@ -60,3 +60,3 @@ for (const t of i) {

exports.skip = skip;
function* take(n, i) {
function* take(i, n) {
let a = 0;

@@ -83,3 +83,3 @@ if (n) {

exports.concat = concat;
function* concatMap(fn, i) {
function* concatMap(i, fn) {
for (const t of i) {

@@ -94,3 +94,3 @@ yield* fn(t);

*/
function* combine(fnMap, i, j) {
function* combine(i, j, fnMap) {
const jit = j[Symbol.iterator]();

@@ -103,4 +103,7 @@ for (const r of i) {

exports.combine = combine;
function map(fnMap, i) {
function* fn(fnMap, i) {
/**
* apply a mapping function to an Iterable.
*/
function map(i, fnMap) {
function* fn(i, fnMap) {
for (const v of i) {

@@ -110,8 +113,3 @@ yield fnMap(v);

}
if (i !== undefined) {
return fn(fnMap, i);
}
return function (i) {
return fn(fnMap, i);
};
return fn(i, fnMap);
}

@@ -141,3 +139,3 @@ exports.map = map;

//// Reducers
function all(fn, i) {
function all(i, fn) {
for (const t of i) {

@@ -151,3 +149,3 @@ if (!fn(t)) {

exports.all = all;
function any(fn, i) {
function any(i, fn) {
for (const t of i) {

@@ -162,6 +160,6 @@ if (fn(t)) {

function count(i) {
return reduce(p => p + 1, 0, i);
return reduce(i, p => p + 1, 0);
}
exports.count = count;
function first(fn, defaultValue, i) {
function first(i, fn, defaultValue) {
fn = fn || (() => true);

@@ -176,3 +174,3 @@ for (const t of i) {

exports.first = first;
function forEach(fn, i) {
function forEach(i, fn) {
let index = 0;

@@ -185,11 +183,11 @@ for (const t of i) {

exports.forEach = forEach;
function max(selector = (t => t), i) {
return reduce((p, c) => selector(c) > selector(p) ? c : p, undefined, i);
function max(i, selector = (t => t)) {
return reduce(i, (p, c) => selector(c) > selector(p) ? c : p, undefined);
}
exports.max = max;
function min(selector = (t => t), i) {
return reduce((p, c) => selector(c) < selector(p) ? c : p, undefined, i);
function min(i, selector = (t => t)) {
return reduce(i, (p, c) => selector(c) < selector(p) ? c : p, undefined);
}
exports.min = min;
function reduce(fnReduce, initialValue, i) {
function reduce(i, fnReduce, initialValue) {
// We need to create a new iterable to prevent for...of from restarting an array.

@@ -212,3 +210,3 @@ const iter = makeIterable(i[Symbol.iterator]());

exports.reduce = reduce;
function reduceAsync(fnReduce, i, initialValue) {
function reduceAsync(i, fnReduce, initialValue) {
return __awaiter(this, void 0, void 0, function* () {

@@ -234,3 +232,3 @@ // We need to create a new iterable to prevent for...of from restarting an array.

exports.reduceAsync = reduceAsync;
function reduceAsyncForAsyncIterator(fnReduce, i, initialValue) {
function reduceAsyncForAsyncIterator(i, fnReduce, initialValue) {
var e_1, _a;

@@ -237,0 +235,0 @@ return __awaiter(this, void 0, void 0, function* () {

2

dist/types.d.ts
export declare type Maybe<T> = T | undefined;
export declare type ThenArg<T> = T extends PromiseLike<PromiseLike<PromiseLike<infer U>>> ? U : T extends PromiseLike<PromiseLike<infer U>> ? U : T extends PromiseLike<infer U> ? U : T;
export declare type ThenArg<T> = T extends PromiseLike<infer U> ? U : T;
export declare type IterableOfPromise<T> = IterableLike<Promise<Promise<T>>> | IterableLike<Promise<T>> | IterableLike<T>;

@@ -4,0 +4,0 @@ export interface IterableLike<T> {

6

package.json
{
"name": "gensequence",
"version": "3.1.0",
"version": "3.1.1",
"description": "Small library to simplify working with Generators and Iterators in Javascript / Typescript",

@@ -21,3 +21,4 @@ "main": "dist/index.js",

"scripts": {
"prepublish": "npm run clean-build && npm test",
"prepublish": "npm run clean-build",
"prepublishOnly": "npm test",
"clean-build": "npm run clean && npm run build",

@@ -50,2 +51,3 @@ "clean": "rimraf dist",

"dist/",
"operators.js",
"!**/samples",

@@ -52,0 +54,0 @@ "!**/*.map",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc