add hw2

node_modules/bare-stream/index.d.ts

@@ -0,0 +1,237 @@
+import EventEmitter, { EventMap } from 'bare-events'
+import Buffer, { BufferEncoding } from 'bare-buffer'
+
+type StreamEncoding = BufferEncoding | 'buffer'
+
+interface StreamCallback {
+  (err: Error | null): void
+}
+
+interface StreamEvents extends EventMap {
+  close: []
+  error: [err: Error]
+}
+
+interface StreamOptions<S extends Stream = Stream> {
+  eagerOpen?: boolean
+  signal?: AbortSignal
+  open?(this: S, cb: StreamCallback): void
+  predestroy?(this: S): void
+  destroy?(this: S, err: Error | null, cb: StreamCallback): void
+}
+
+interface Stream<M extends StreamEvents = StreamEvents>
+  extends EventEmitter<M> {
+  _open(cb: StreamCallback): void
+  _predestroy(): void
+  _destroy(err: Error | null, cb: StreamCallback): void
+
+  readonly readable: boolean
+  readonly writable: boolean
+  readonly destroyed: boolean
+  readonly destroying: boolean
+
+  destroy(err?: Error | null): void
+}
+
+declare class Stream {}
+
+interface ReadableEvents extends StreamEvents {
+  data: [data: unknown]
+  end: []
+  readable: []
+  piping: [dest: Writable]
+}
+
+interface ReadableOptions<S extends Readable = Readable>
+  extends StreamOptions<S> {
+  encoding?: BufferEncoding
+  highWaterMark?: number
+  read?(this: S, size: number): void
+}
+
+interface Readable<M extends ReadableEvents = ReadableEvents>
+  extends Stream<M>,
+    AsyncIterable<unknown> {
+  _read(size: number): void
+
+  push(data: unknown | null, encoding?: BufferEncoding): boolean
+  unshift(data: unknown | null, encoding?: BufferEncoding): boolean
+  read(): unknown | null
+
+  resume(): this
+  pause(): this
+
+  pipe<S extends Writable>(dest: S, cb?: StreamCallback): S
+
+  setEncoding(encoding: BufferEncoding): void
+}
+
+declare class Readable<
+  M extends ReadableEvents = ReadableEvents
+> extends Stream<M> {
+  constructor(opts?: ReadableOptions)
+
+  static from(
+    data: unknown | unknown[] | AsyncIterable<unknown>,
+    opts?: ReadableOptions
+  ): Readable
+
+  static isBackpressured(rs: Readable): boolean
+
+  static isPaused(rs: Readable): boolean
+}
+
+interface WritableEvents extends StreamEvents {
+  drain: []
+  finish: []
+  pipe: [src: Readable]
+}
+
+interface WritableOptions<S extends Writable = Writable>
+  extends StreamOptions<S> {
+  write?(
+    this: S,
+    data: unknown,
+    encoding: StreamEncoding,
+    cb: StreamCallback
+  ): void
+  writev?(
+    this: S,
+    batch: { chunk: unknown; encoding: StreamEncoding }[],
+    cb: StreamCallback
+  ): void
+  final?(this: S, cb: StreamCallback): void
+}
+
+interface Writable<M extends WritableEvents = WritableEvents>
+  extends Stream<M> {
+  _write(data: unknown, encoding: StreamEncoding, cb: StreamCallback): void
+  _writev(
+    batch: { chunk: unknown; encoding: StreamEncoding }[],
+    cb: StreamCallback
+  ): void
+  _final(cb: StreamCallback): void
+
+  readonly destroyed: boolean
+
+  write(data: unknown, encoding?: BufferEncoding, cb?: StreamCallback): boolean
+  write(data: unknown, cb?: StreamCallback): boolean
+
+  end(cb?: StreamCallback): this
+  end(data: unknown, encoding?: BufferEncoding, cb?: StreamCallback): this
+  end(data: unknown, cb?: StreamCallback): this
+
+  cork(): void
+  uncork(): void
+}
+
+declare class Writable<
+  M extends WritableEvents = WritableEvents
+> extends Stream<M> {
+  constructor(opts?: WritableOptions)
+
+  static isBackpressured(ws: Writable): boolean
+
+  static drained(ws: Writable): Promise<boolean>
+}
+
+interface DuplexEvents extends ReadableEvents, WritableEvents {}
+
+interface DuplexOptions<S extends Duplex = Duplex>
+  extends ReadableOptions<S>,
+    WritableOptions<S> {}
+
+interface Duplex<M extends DuplexEvents = DuplexEvents>
+  extends Readable<M>,
+    Writable<M> {}
+
+declare class Duplex<M extends DuplexEvents = DuplexEvents> extends Stream<M> {
+  constructor(opts?: DuplexOptions)
+}
+
+interface TransformEvents extends DuplexEvents {}
+
+interface TransformOptions<S extends Transform = Transform>
+  extends DuplexOptions<S> {
+  transform?(
+    this: S,
+    data: unknown,
+    encoding: StreamEncoding,
+    cb: StreamCallback
+  ): void
+  flush?(this: S, cb: StreamCallback): void
+}
+
+interface Transform<M extends TransformEvents = TransformEvents>
+  extends Duplex<M> {
+  _transform(data: unknown, encoding: StreamEncoding, cb: StreamCallback): void
+  _flush(cb: StreamCallback): void
+}
+
+declare class Transform<
+  M extends TransformEvents = TransformEvents
+> extends Duplex<M> {
+  constructor(opts?: TransformOptions)
+}
+
+type Pipeline<S extends Writable> = [
+  src: Readable,
+  ...transforms: Duplex[],
+  dest: S
+]
+
+declare namespace Stream {
+  export {
+    Stream,
+    StreamEvents,
+    StreamOptions,
+    Readable,
+    ReadableEvents,
+    ReadableOptions,
+    Writable,
+    WritableEvents,
+    WritableOptions,
+    Duplex,
+    DuplexEvents,
+    DuplexOptions,
+    Transform,
+    TransformEvents,
+    TransformOptions,
+    Transform as PassThrough
+  }
+
+  export function pipeline<S extends Writable>(
+    streams: Pipeline<S>,
+    cb?: StreamCallback
+  ): S
+
+  export function pipeline<S extends Writable>(...args: Pipeline<S>): S
+
+  export function pipeline<S extends Writable>(
+    ...args: [...Pipeline<S>, cb: StreamCallback]
+  ): S
+
+  export function finished(
+    stream: Stream,
+    opts: { cleanup?: boolean },
+    cb: StreamCallback
+  ): () => void
+
+  export function finished(stream: Stream, cb: StreamCallback): () => void
+
+  export function isStream(stream: unknown): stream is Stream
+
+  export function isEnded(stream: Stream): boolean
+
+  export function isFinished(stream: Stream): boolean
+
+  export function isDisturbed(stream: Stream): boolean
+
+  export function getStreamError(
+    stream: Stream,
+    opts?: { all?: boolean }
+  ): Error | null
+}
+
+export = Stream