fix(node:stream): add placeholder for not implemented new method

unjs · Aug 25, 2023 · 294f283 · 294f283
1 parent 54331de
commit 294f283
Show file tree

Hide file tree

Showing 2 changed files with 137 additions and 8 deletions.
diff --git a/src/runtime/_internal/utils.ts b/src/runtime/_internal/utils.ts
@@ -23,9 +23,13 @@ export function mergeFns(...functions: Fn[]) {
   };
 }
 
+export function createNotImplementedError(name: string) {
+  throw new Error(`[unenv] ${name} is not implemented yet!`);
+}
+
 export function notImplemented(name: string) {
   const fn = (): any => {
-    throw new Error(`[unenv] ${name} is not implemented yet!`);
+    throw createNotImplementedError(name);
   };
   return Object.assign(fn, { __unenv__: true });
 }

diff --git a/src/runtime/node/stream/readable.ts b/src/runtime/node/stream/readable.ts
@@ -1,11 +1,18 @@
 import type * as stream from "node:stream";
 import type { BufferEncoding, Callback } from "../../_internal/types";
-
+import { createNotImplementedError } from "../../_internal/utils";
 import { EventEmitter } from "../events";
 
 // Docs: https://nodejs.org/api/stream.html#stream_readable_streams
 // Implementation: https://github.com/nodejs/node/blob/master/lib/internal/streams/readable.js
 
+interface ArrayOptions {
+  /** the maximum concurrent invocations of `fn` to call on the stream at once. **Default: 1**. */
+  concurrency?: number;
+  /** allows destroying the stream if the signal is aborted. */
+  signal?: AbortSignal;
+}
+
 // eslint-disable-next-line unicorn/prefer-event-target
 export class _Readable extends EventEmitter implements stream.Readable {
   __unenv__: unknown = true;
@@ -83,18 +90,136 @@ export class _Readable extends EventEmitter implements stream.Readable {
     return {} as T;
   }
 
-  async *[Symbol.asyncIterator](): AsyncIterableIterator<any> {}
+  compose<T extends NodeJS.ReadableStream>(
+    stream: T | ((source: any) => void) | Iterable<T> | AsyncIterable<T>,
+    options?: { signal: AbortSignal } | undefined,
+  ): T {
+    throw new Error("[unenv] Method not implemented.");
+  }
 
   [Symbol.asyncDispose]() {
     this.destroy();
     return Promise.resolve();
   }
 
-  compose<T extends NodeJS.ReadableStream>(
-    stream: T | ((source: any) => void) | Iterable<T> | AsyncIterable<T>,
-    options?: { signal: AbortSignal } | undefined,
-  ): T {
-    throw new Error("[h3] Method not implemented.");
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<any> {
+    throw createNotImplementedError("Readable.asyncIterator");
+  }
+
+  iterator(
+    options?: { destroyOnReturn?: boolean | undefined } | undefined,
+  ): AsyncIterableIterator<any> {
+    throw createNotImplementedError("Readable.iterator");
+  }
+
+  map(
+    fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => any,
+    options?: ArrayOptions | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.map");
+  }
+
+  filter(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => boolean,
+    options?: ArrayOptions | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.filter");
+  }
+
+  forEach(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => void | Promise<void>,
+    options?: ArrayOptions | undefined,
+  ): Promise<void> {
+    throw createNotImplementedError("Readable.forEach");
+  }
+
+  reduce(
+    fn: (
+      accumulator: any,
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => any,
+    initialValue?: any,
+    options?: ArrayOptions | undefined,
+  ): Promise<any> {
+    throw createNotImplementedError("Readable.reduce");
+  }
+
+  find(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => boolean,
+    options?: ArrayOptions | undefined,
+  ): Promise<any> {
+    throw createNotImplementedError("Readable.find");
+  }
+
+  findIndex(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => boolean,
+    options?: ArrayOptions | undefined,
+  ): Promise<number> {
+    throw createNotImplementedError("Readable.findIndex");
+  }
+
+  some(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => boolean,
+    options?: ArrayOptions | undefined,
+  ): Promise<boolean> {
+    throw createNotImplementedError("Readable.some");
+  }
+
+  toArray(options?: Pick<ArrayOptions, "signal"> | undefined): Promise<any[]> {
+    throw createNotImplementedError("Readable.toArray");
+  }
+
+  every(
+    fn: (
+      data: any,
+      options?: Pick<ArrayOptions, "signal"> | undefined,
+    ) => boolean | Promise<boolean>,
+    options?: ArrayOptions | undefined,
+  ): Promise<boolean> {
+    throw createNotImplementedError("Readable.every");
+  }
+
+  flatMap(
+    fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => any,
+    options?: ArrayOptions | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.flatMap");
+  }
+
+  drop(
+    limit: number,
+    options?: Pick<ArrayOptions, "signal"> | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.drop");
+  }
+
+  take(
+    limit: number,
+    options?: Pick<ArrayOptions, "signal"> | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.take");
+  }
+
+  asIndexedPairs(
+    options?: Pick<ArrayOptions, "signal"> | undefined,
+  ): stream.Readable {
+    throw createNotImplementedError("Readable.asIndexedPairs");
   }
 }