@hyperjump/pact - npm Package Compare versions

Comparing version 1.1.0 to 1.2.0

lib/async.js

@@ -9,7 +9,11 @@ export {
   asyncTake as take,
+  asyncHead as head,
   range,
+  asyncEmpty as empty,
   asyncZip as zip,
+  asyncConcat as concat,
   asyncReduce as reduce,
   asyncEvery as every,
   asyncSome as some,
+  asyncCount as count,
   asyncCollectArray as collectArray,
@@ -19,3 +23,4 @@ asyncCollectSet as collectSet,
   asyncCollectObject as collectObject,
+  asyncJoin as join,
   pipe
 } from "./index.js";

lib/index.d.ts

@@ -9,5 +9,5 @@ export const map: (
 export const asyncMap: (
-  <A, B>(fn: AsyncMapper<A, B>, iterator: AsyncIterable<A>) => AsyncGenerator<B>
+  <A, B>(fn: AsyncMapper<A, B>, iterator: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<B>
 ) & (
-  <A, B>(fn: AsyncMapper<A, B>) => (iterator: AsyncIterable<A>) => AsyncGenerator<B>
+  <A, B>(fn: AsyncMapper<A, B>) => (iterator: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<B>
 );
@@ -21,10 +21,9 @@ export type AsyncMapper<A, B> = (item: A) => Promise<B> | B;
 );
-export type Tapper<A> = (item: A) => void;
+export type Tapper<A> = (item: A) => void | Promise<void>;
 
 export const asyncTap: (
-  <A>(fn: AsyncTapper<A>, iterator: AsyncIterable<A>) => AsyncGenerator<A>
+  <A>(fn: Tapper<A>, iterator: AsyncIterable<A>) => AsyncGenerator<A>
 ) & (
-  <A>(fn: AsyncTapper<A>) => (iterator: AsyncIterable<A>) => AsyncGenerator<A>
+  <A>(fn: Tapper<A>) => (iterator: AsyncIterable<A>) => AsyncGenerator<A>
 );
-export type AsyncTapper<A> = (item: A) => void;
 
@@ -39,5 +38,5 @@ export const filter: (
 export const asyncFilter: (
-  <A>(fn: AsyncPredicate<A>, iterator: AsyncIterable<A>) => AsyncGenerator<A>
+  <A>(fn: AsyncPredicate<A>, iterator: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<A>
 ) & (
-  <A>(fn: AsyncPredicate<A>) => (iterator: AsyncIterable<A>) => AsyncGenerator<A>
+  <A>(fn: AsyncPredicate<A>) => (iterator: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<A>
 );
@@ -53,5 +52,5 @@ export type AsyncPredicate<A> = (item: A) => Promise<boolean> | boolean;
 export const asyncScan: (
-  <A, B>(fn: AsyncReducer<A, B>, acc: B, iter: AsyncIterable<A>) => AsyncGenerator<B>
+  <A, B>(fn: AsyncReducer<A, B>, acc: B, iter: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<B>
 ) & (
-  <A, B>(fn: AsyncReducer<A, B>, acc: B) => (iter: AsyncIterable<A>) => AsyncGenerator<B>
+  <A, B>(fn: AsyncReducer<A, B>, acc: B) => (iter: Iterable<A> | AsyncIterable<A>) => AsyncGenerator<B>
 );
@@ -89,7 +88,16 @@
 
+export const head: <A>(iterator: Iterable<A>) => A | undefined;
+export const asyncHead: <A>(iterator: AsyncIterable<A>) => Promise<A | undefined>;
+
 export const range: (from: number, to?: number) => Generator<number>;
 
+export const empty: <A>() => Generator<A>;
+export const asyncEmpty: <A>() => AsyncGenerator<A>;
+
 export const zip: <A, B>(iter1: Iterable<A>, iter2: Iterable<B>) => Generator<[A, B]>;
 export const asyncZip: <A, B>(iter1: AsyncIterable<A>, iter2: AsyncIterable<B>) => AsyncGenerator<[A, B]>;
 
+export const concat: <A>(...iters: Iterable<A>[]) => Generator<A>;
+export const asyncConcat: <A>(...iters: (Iterable<A> | AsyncIterable<A>)[]) => AsyncGenerator<A>;
+
 export const reduce: (
@@ -103,5 +111,5 @@ <A, B>(fn: Reducer<A, B>, acc: B, iter: Iterable<A>) => B
 export const asyncReduce: (
-  <A, B>(fn: AsyncReducer<A, B>, acc: B, iter: AsyncIterable<A>) => Promise<B>
+  <A, B>(fn: AsyncReducer<A, B>, acc: B, iter: Iterable<A> | AsyncIterable<A>) => Promise<B>
 ) & (
-  <A, B>(fn: AsyncReducer<A, B>, acc: B) => (iter: AsyncIterable<A>) => Promise<B>
+  <A, B>(fn: AsyncReducer<A, B>, acc: B) => (iter: Iterable<A> | AsyncIterable<A>) => Promise<B>
 );
@@ -117,5 +125,5 @@ export type AsyncReducer<A, B> = (acc: B, item: A) => Promise<B> | B;
 export const asyncEvery: (
-  <A>(fn: AsyncPredicate<A>, iterator: AsyncIterable<A>) => Promise<boolean>
+  <A>(fn: AsyncPredicate<A>, iterator: Iterable<A> | AsyncIterable<A>) => Promise<boolean>
 ) & (
-  <A>(fn: AsyncPredicate<A>) => (iterator: AsyncIterable<A>) => Promise<boolean>
+  <A>(fn: AsyncPredicate<A>) => (iterator: Iterable<A> | AsyncIterable<A>) => Promise<boolean>
 );
@@ -130,7 +138,10 @@
 export const asyncSome: (
-  <A>(fn: AsyncPredicate<A>, iterator: AsyncIterable<A>) => Promise<boolean>
+  <A>(fn: AsyncPredicate<A>, iterator: Iterable<A> | AsyncIterable<A>) => Promise<boolean>
 ) & (
-  <A>(fn: AsyncPredicate<A>) => (iterator: AsyncIterable<A>) => Promise<boolean>
+  <A>(fn: AsyncPredicate<A>) => (iterator: Iterable<A> | AsyncIterable<A>) => Promise<boolean>
 );
 
+export const count: <A>(iterator: Iterable<A>) => number;
+export const asyncCount: <A>(iterator: AsyncIterable<A>) => Promise<number>;
+
 export const collectArray: <A>(iterator: Iterable<A>) => A[];
@@ -148,3 +159,15 @@ export const asyncCollectArray: <A>(iterator: AsyncIterable<A>) => Promise<A[]>;
 
+export const join: (
+  (separator: string, iterator: Iterable<string>) => string
+) & (
+  (separator: string) => (iterator: Iterable<string>) => string
+);
+
+export const asyncJoin: (
+  (separator: string, iterator: AsyncIterable<string>) => Promise<string>
+) & (
+  (separator: string) => (iterator: AsyncIterable<string>) => Promise<string>
+);
+
 // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any
 export const pipe: <A>(iterator: Iterable<any> | AsyncIterable<any>, ...fns: Function[]) => A;

lib/index.js

@@ -99,9 +99,7 @@ import curry from "just-curry-it";
 export const take = curry(function* (count, iter) {
-  let index = 0;
-  for (const item of iter) {
-    if (index++ >= count) {
-      break;
-    }
+  const iterator = getIterator(iter);
 
-    yield item;
+  let current;
+  while (count-- > 0 && !(current = iterator.next())?.done) {
+    yield current.value;
   }
@@ -111,12 +109,24 @@ });
 export const asyncTake = curry(async function* (count, iter) {
-  let index = 0;
-  for await (const item of iter) {
-    if (index++ >= count) {
-      break;
-    }
+  const iterator = getAsyncIterator(iter);
 
-    yield item;
+  let current;
+  while (count-- > 0 && !(current = await iterator.next())?.done) {
+    yield current.value;
   }
 });
 
+export const head = (iter) => {
+  const iterator = getIterator(iter);
+  const result = iterator.next();
+
+  return result.done ? undefined : result.value;
+};
+
+export const asyncHead = async (iter) => {
+  const iterator = getAsyncIterator(iter);
+  const result = await iterator.next();
+
+  return result.done ? undefined : result.value;
+};
+
 export const range = function* (from, to) {
@@ -129,2 +139,5 @@ // eslint-disable-next-line no-unmodified-loop-condition
 
+export const empty = function* () {}; // eslint-disable-line no-empty-function
+export const asyncEmpty = async function* () {}; // eslint-disable-line no-empty-function
+
 export const zip = function* (iter1, iter2) {
@@ -142,2 +155,14 @@ for (const item1 of iter1) {
 
+export const concat = function* (...iters) {
+  for (const iter of iters) {
+    yield* iter;
+  }
+};
+
+export const asyncConcat = async function* (...iters) {
+  for (const iter of iters) {
+    yield* iter;
+  }
+};
+
 export const reduce = curry((fn, acc, iter) => {
@@ -199,2 +224,5 @@ for (const item of iter) {
 
+export const count = (iter) => reduce((count) => count + 1, 0, iter);
+export const asyncCount = (iter) => asyncReduce((count) => count + 1, 0, iter);
+
 export const collectArray = (iter) => [...iter];
@@ -264,2 +292,40 @@ export const asyncCollectArray = async (iter) => {
 
+export const join = curry((separator, iter) => {
+  let result = head(iter) || "";
+
+  for (const n of iter) {
+    result += separator + n;
+  }
+
+  return result;
+});
+
+export const asyncJoin = curry(async (separator, iter) => {
+  let result = await asyncHead(iter) || "";
+
+  for await (const n of iter) {
+    result += separator + n;
+  }
+
+  return result;
+});
+
+const getIterator = (iter) => {
+  if (typeof iter?.[Symbol.iterator] === "function") {
+    return iter[Symbol.iterator]();
+  } else {
+    throw TypeError("`iter` is not iterable");
+  }
+};
+
+const getAsyncIterator = (iter) => {
+  if (typeof iter?.[Symbol.asyncIterator] === "function") {
+    return iter[Symbol.asyncIterator]();
+  } else if (typeof iter?.[Symbol.iterator] === "function") {
+    return iter[Symbol.iterator]();
+  } else {
+    throw TypeError("`iter` is not iterable");
+  }
+};
+
 export const pipe = (acc, ...fns) => reduce((acc, fn) => fn(acc), acc, fns);

package.json

 {
   "name": "@hyperjump/pact",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Higher order functions for iterators and async iterators",
@@ -5,0 +5,0 @@ "type": "module",

README.md

@@ -61,3 +61,3 @@ # Hyperjump Pact
 
-    Same as `map`, but works with promises.
+    Same as `map`, but works with AsyncGenerators and async mapping functions.
 * **tap**: (fn: Function, iterator: Iterable) => Generator
@@ -69,3 +69,3 @@
 
-    Same as `tap`, but works with promises.
+    Same as `tap`, but works with AsyncGenerators.
 * **filter**: (fn: Function, iterator: Iterable) => Generator
@@ -76,3 +76,4 @@
 
-    Same as `filter`, but works with promises.
+    Same as `filter`, but works with AsyncGenerators and async predicate
+    functions.
 * **scan**: (fn: Function, acc: any, iter: Iterable) => any
@@ -83,3 +84,4 @@
 
-    Same as `scan`, but works with promises.
+    Same as `scan`, but works with AsyncGenerators and async predicate
+    functions.
 * **flatten**: (iterator: NestedIterable, depth: number = 1) => Generator
@@ -91,3 +93,3 @@
 
-    Same as `flatten`, but works with promises.
+    Same as `flatten`, but works with AsyncGenerators.
 * **drop**: (n: number, iterator: Iterable) => Generator
@@ -98,9 +100,15 @@
 
-    Same as `drop`, but works with promises.
+    Same as `drop`, but works with AsyncGenerators.
 * **take**: (n: number, iterator: Iterable) => Generator
 
     Yields the first `n` values in the iterator.
-* **asyncTake**: (count: number, iterator: AsyncIterable) => AsyncGenerator
+* **asyncTake**: (n: number, iterator: AsyncIterable) => AsyncGenerator
 
-    Same as `take`, but works with promises.
+    Same as `take`, but works with AsyncGenerators.
+* **head**: (iterator: Iterable) => A
+
+    Returns the first value in the iterator.
+* **asyncHead**: (iterator: AsyncIterable) => A
+
+    Same as `head`, but works with AsyncGenerators.
 * **range**: (from: number, to?: number) => Generator
@@ -110,2 +118,8 @@
     iterator will be infinite.
+* **empty**: () => Generator
+
+    Yields nothing.
+* **asyncEmpty**: () => AsyncGenerator
+
+    Yields nothing asynchronously.
 * **zip**: (iter1: Iterable, iter2: Iterable) => Generator
@@ -119,9 +133,16 @@
 
-    Same as `zip` but works with promises.
+    Same as `zip` but works with AsyncGenerators.
+* **concat**: (...iters: Iterable[]) => Generator
+
+    Yields values from each iterator in order.
+* **asyncConcat**: (...iters: AsyncIterable[]) => AsyncGenerator
+
+    Same as `concat` but works with AsyncGenerators.
 * **reduce**: (fn: Function, acc: any, iter: Iterable) => any
 
     Reduce an iterator to a single value.
-* **asyncReduce**: (fn: Function, acc: any, iter: AsyncIterable) => Promise<any>
+* **asyncReduce**: (fn: Function, acc: A, iter: AsyncIterable) => Promise<A>
 
-    Same as `reduce`, but works with promises.
+    Same as `reduce`, but works with AsyncGenerators and async reducer
+    functions.
 * **every**: (fn: Function, iterator: Iterable) => boolean
@@ -133,3 +154,4 @@
 
-    Same as `every`, but works with promises.
+    Same as `every`, but works with AsyncGenerators and async predicate
+    functions.
 * **some**: (fn: Function, iterator: Iterable) => boolean
@@ -141,3 +163,10 @@
 
-    Same as `some`, but works with promises.
+    Same as `some`, but works with AsyncGenerators and async predicate
+    functions.
+* **count**: (iterator: Iterable) => number
+
+    Returns the number of items in the iterator.
+* **asyncCount**: (iterator: AsyncIterable) => Promise<number>
+
+    Same as `count`, but works with AsyncGenerators.
 * **collectArray**: (iterator: Iterable) => Array;
@@ -148,3 +177,3 @@
 
-    Same as `collectArray`, but works with promises.
+    Same as `collectArray`, but works with AsyncGenerators.
 * **collectSet**: (iterator: Iterable) => Set;
@@ -155,3 +184,3 @@
 
-    Same as `collectSet`, but works with promises.
+    Same as `collectSet`, but works with AsyncGenerators.
 * **collectMap**: (iterator: Iterable) => Map;
@@ -162,3 +191,3 @@
 
-    Same as `collectMap`, but works with promises.
+    Same as `collectMap`, but works with AsyncGenerators.
 * **collectObject**: (iterator: Iterable) => Object;
@@ -169,3 +198,10 @@
 
-    Same as `collectObject`, but works with promises.
+    Same as `collectObject`, but works with AsyncGenerators.
+* **join**: (separator: string, iterator: Iterable) => string;
+
+    Collect all the items in the iterator into a string separated by the
+    separator token.
+* **asyncJoin**: (separator: string, iterator: AsyncIterable) => Promise<string>;
+
+    Same as `join`, but works with AsyncGenerators.
 * **pipe**: (iterator: Iterable | AsyncIterable, ...fns: Function) => any;
@@ -172,0 +208,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

22854

increased by22.77%

Lines of code

418

increased by20.81%

Number of lines in readme file

216

increased by20%

No dependency changes