fp-pack 0.1.0

package/src/stream/takeWhile.ts

@@ -0,0 +1,45 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** takeWhile - lazily take values while predicate holds */
+function takeWhile<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => IterableIterator<T>;
+function takeWhile<T>(
+  predicate: (value: T) => boolean | Promise<boolean>
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<T>;
+function takeWhile<T>(predicate: (value: T) => boolean, iterable: Iterable<T>): IterableIterator<T>;
+function takeWhile<T>(
+  predicate: (value: T) => boolean | Promise<boolean>,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): AsyncIterableIterator<T>;
+function takeWhile<T>(predicate: (value: T) => boolean | Promise<boolean>, iterable?: AnyIterableInput<PromiseLikeValue<T>>): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => takeWhile(predicate, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      for await (const item of toAsync(iterable)) {
+        if (!(await predicate(item as T))) {
+          break;
+        }
+        yield item as T;
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      for (const item of iterable) {
+        if (!predicate(item as T)) {
+          break;
+        }
+        yield item as T;
+      }
+    })();
+  }
+
+  throw new TypeError('takeWhile: input is not iterable');
+}
+
+export default takeWhile;

package/src/stream/toArray.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import toArray from './toArray';
+
+const asyncGen = async function* () {
+  yield 1;
+  yield Promise.resolve(2);
+};
+
+describe('stream toArray', () => {
+  it('collects sync iterable', async () => {
+    const result = await toArray([1, 2, 3]);
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('collects async iterable', async () => {
+    const result = await toArray(asyncGen());
+    expect(result).toEqual([1, 2]);
+  });
+});

package/src/stream/toArray.ts

@@ -0,0 +1,26 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { awaitValue, isAsyncIterable, isIterable, resolveIterable } from './utils';
+
+/** toArray - Iterable/AsyncIterable을 배열로 수집 */
+async function toArray<T>(input: AnyIterableInput<PromiseLikeValue<T>>): Promise<T[]> {
+  const resolved = await resolveIterable(input);
+  const result: T[] = [];
+
+  if (isAsyncIterable(resolved)) {
+    for await (const item of resolved) {
+      result.push(await awaitValue(item));
+    }
+    return result;
+  }
+
+  if (isIterable(resolved)) {
+    for (const item of resolved) {
+      result.push(await awaitValue(item));
+    }
+    return result;
+  }
+
+  throw new TypeError('toArray: input is not iterable');
+}
+
+export default toArray;

package/src/stream/toAsync.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import toAsync from './toAsync';
+import toArray from './toArray';
+
+describe('stream toAsync', () => {
+  it('converts iterable of promises', async () => {
+    const input = [Promise.resolve(1), Promise.resolve(2), 3];
+    const result = await toArray(toAsync(input));
+    expect(result).toEqual([1, 2, 3]);
+  });
+});

package/src/stream/toAsync.ts

@@ -0,0 +1,30 @@
+import type { AnyIterable, AnyIterableInput, PromiseLikeValue } from './utils';
+import { awaitValue, isAsyncIterable, isIterable, resolveIterable } from './utils';
+
+/** toAsync - Iterable/AsyncIterable을 AsyncIterable로 승격 */
+function toAsync<T>(input: AnyIterableInput<PromiseLikeValue<T>>): AsyncIterable<T> {
+  const iterator = async function* () {
+    const resolved = await resolveIterable(input);
+
+    if (isAsyncIterable(resolved)) {
+      for await (const item of resolved) {
+        yield await awaitValue(item);
+      }
+      return;
+    }
+
+    if (isIterable(resolved)) {
+      for (const item of resolved) {
+        yield await awaitValue(item);
+      }
+      return;
+    }
+
+    throw new TypeError('toAsync: input is not iterable');
+  };
+
+  return iterator();
+}
+
+export default toAsync;
+export type { AnyIterable };

package/src/stream/utils.ts

@@ -0,0 +1,30 @@
+type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;
+type AnyIterableInput<T> = AnyIterable<T> | Promise<AnyIterable<T>>;
+
+type PromiseLikeValue<T> = T | PromiseLike<T>;
+
+const isPromiseLike = (value: unknown): value is PromiseLike<unknown> =>
+  typeof value === 'object' && value !== null && 'then' in value && typeof (value as PromiseLike<unknown>).then === 'function';
+
+const isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> =>
+  typeof value === 'object' &&
+  value !== null &&
+  Symbol.asyncIterator in value &&
+  typeof (value as AsyncIterable<unknown>)[Symbol.asyncIterator] === 'function';
+
+const isIterable = (value: unknown): value is Iterable<unknown> =>
+  typeof value === 'object' &&
+  value !== null &&
+  Symbol.iterator in value &&
+  typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function';
+
+const isAsyncInput = (value: unknown): value is PromiseLike<AnyIterable<unknown>> | AsyncIterable<unknown> =>
+  isPromiseLike(value) || isAsyncIterable(value);
+
+const resolveIterable = async <T>(input: AnyIterableInput<T>): Promise<AnyIterable<T>> =>
+  (isPromiseLike(input) ? await input : input) as AnyIterable<T>;
+
+const awaitValue = async <T>(value: PromiseLikeValue<T>): Promise<T> => (isPromiseLike(value) ? await value : value);
+
+export type { AnyIterable, AnyIterableInput, PromiseLikeValue };
+export { isPromiseLike, isAsyncIterable, isIterable, isAsyncInput, resolveIterable, awaitValue };

package/src/stream/zip.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import zip from './zip';
+import toArray from './toArray';
+
+describe('stream zip', () => {
+  it('zips sync iterables', () => {
+    const result = Array.from(zip(['a', 'b'], [1, 2, 3]));
+    expect(result).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+  });
+
+  it('supports data-last usage', () => {
+    const zipper = zip(['x', 'y']);
+    expect(Array.from(zipper([10, 20, 30]))).toEqual([
+      [10, 'x'],
+      [20, 'y'],
+    ]);
+  });
+
+  it('zips async inputs', async () => {
+    const result = await toArray(zip(Promise.resolve(['q', 'w']), Promise.resolve([1, 2, 3])));
+    expect(result).toEqual([
+      [1, 'q'],
+      [2, 'w'],
+    ]);
+  });
+});

package/src/stream/zip.ts

@@ -0,0 +1,56 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** zip - lazily combine two iterables */
+function zip<A, B>(other: Iterable<B>): (iterable: Iterable<A>) => IterableIterator<[A, B]>;
+function zip<A, B>(
+  other: AnyIterableInput<PromiseLikeValue<B>>
+): (iterable: AnyIterableInput<PromiseLikeValue<A>>) => AsyncIterableIterator<[A, B]>;
+function zip<A, B>(other: Iterable<B>, iterable: Iterable<A>): IterableIterator<[A, B]>;
+function zip<A, B>(
+  other: AnyIterableInput<PromiseLikeValue<B>>,
+  iterable: AnyIterableInput<PromiseLikeValue<A>>
+): AsyncIterableIterator<[A, B]>;
+function zip<A, B>(other: AnyIterableInput<PromiseLikeValue<B>>, iterable?: AnyIterableInput<PromiseLikeValue<A>>): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<A>>) => zip(other, next);
+  }
+
+  if (isAsyncInput(other) || isAsyncInput(iterable)) {
+    return (async function* () {
+      const left = toAsync(iterable);
+      const right = toAsync(other);
+      const leftIter = left[Symbol.asyncIterator]();
+      const rightIter = right[Symbol.asyncIterator]();
+
+      while (true) {
+        const [leftResult, rightResult] = await Promise.all([leftIter.next(), rightIter.next()]);
+        if (leftResult.done || rightResult.done) {
+          return;
+        }
+        yield [leftResult.value as A, rightResult.value as B];
+      }
+    })();
+  }
+
+  if (isIterable(iterable) && isIterable(other)) {
+    return (function* () {
+      const leftIter = (iterable as Iterable<A>)[Symbol.iterator]();
+      const rightIter = (other as Iterable<B>)[Symbol.iterator]();
+
+      while (true) {
+        const leftResult = leftIter.next();
+        const rightResult = rightIter.next();
+        if (leftResult.done || rightResult.done) {
+          return;
+        }
+        yield [leftResult.value as A, rightResult.value as B];
+      }
+    })();
+  }
+
+  throw new TypeError('zip: input is not iterable');
+}
+
+export default zip;

package/src/stream/zipWith.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import zipWith from './zipWith';
+import toArray from './toArray';
+
+describe('stream zipWith', () => {
+  it('zips with function (sync)', () => {
+    const result = Array.from(zipWith((a: number, b: number) => a + b, [10, 20], [1, 2, 3]));
+    expect(result).toEqual([11, 22]);
+  });
+
+  it('supports data-last usage', () => {
+    const zipper = zipWith((a: number, b: number) => a * b, [2, 3]);
+    expect(Array.from(zipper([4, 5, 6]))).toEqual([8, 15]);
+  });
+
+  it('zips with function (async)', async () => {
+    const result = await toArray(
+      zipWith(async (a: number, b: number) => a + b, Promise.resolve([10, 20]), Promise.resolve([1, 2, 3]))
+    );
+    expect(result).toEqual([11, 22]);
+  });
+});

package/src/stream/zipWith.ts

@@ -0,0 +1,62 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** zipWith - lazily combine two iterables with a function */
+function zipWith<A, B, R>(fn: (a: A, b: B) => R, other: Iterable<B>): (iterable: Iterable<A>) => IterableIterator<R>;
+function zipWith<A, B, R>(
+  fn: (a: A, b: B) => R | Promise<R>,
+  other: AnyIterableInput<PromiseLikeValue<B>>
+): (iterable: AnyIterableInput<PromiseLikeValue<A>>) => AsyncIterableIterator<R>;
+function zipWith<A, B, R>(fn: (a: A, b: B) => R, other: Iterable<B>, iterable: Iterable<A>): IterableIterator<R>;
+function zipWith<A, B, R>(
+  fn: (a: A, b: B) => R | Promise<R>,
+  other: AnyIterableInput<PromiseLikeValue<B>>,
+  iterable: AnyIterableInput<PromiseLikeValue<A>>
+): AsyncIterableIterator<R>;
+function zipWith<A, B, R>(
+  fn: (a: A, b: B) => R | Promise<R>,
+  other: AnyIterableInput<PromiseLikeValue<B>>,
+  iterable?: AnyIterableInput<PromiseLikeValue<A>>
+): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<A>>) => zipWith(fn, other, next);
+  }
+
+  if (isAsyncInput(other) || isAsyncInput(iterable)) {
+    return (async function* () {
+      const left = toAsync(iterable);
+      const right = toAsync(other);
+      const leftIter = left[Symbol.asyncIterator]();
+      const rightIter = right[Symbol.asyncIterator]();
+
+      while (true) {
+        const [leftResult, rightResult] = await Promise.all([leftIter.next(), rightIter.next()]);
+        if (leftResult.done || rightResult.done) {
+          return;
+        }
+        yield await fn(leftResult.value as A, rightResult.value as B);
+      }
+    })();
+  }
+
+  if (isIterable(iterable) && isIterable(other)) {
+    return (function* () {
+      const leftIter = (iterable as Iterable<A>)[Symbol.iterator]();
+      const rightIter = (other as Iterable<B>)[Symbol.iterator]();
+
+      while (true) {
+        const leftResult = leftIter.next();
+        const rightResult = rightIter.next();
+        if (leftResult.done || rightResult.done) {
+          return;
+        }
+        yield fn(leftResult.value as A, rightResult.value as B) as R;
+      }
+    })();
+  }
+
+  throw new TypeError('zipWith: input is not iterable');
+}
+
+export default zipWith;