chore(typescript): update to typescript@5.3.3 (#358)

* chore(typescript): update to typescript@5.3.3 (fixes #345)

* chore(dependencies): update @types/node (fixes #335)

* fix(withabort): add ts-ignore to withabort operator impl (fixes #345)

package.json

@@ -47,7 +47,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@types/node": "^13.7.4",
+    "@types/node": ">=13.7.4",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
@@ -99,7 +99,7 @@
     "ts-jest": "28.0.7",
     "ts-node": "8.6.2",
     "typedoc": "0.16.10",
-    "typescript": "4.6.2",
+    "typescript": "5.3.3",
     "validate-commit-msg": "2.14.0",
     "web-stream-tools": "0.0.1",
     "web-streams-polyfill": "2.1.0",

src/asynciterable/asasynciterable.ts

@@ -2,39 +2,52 @@ import { AsyncIterableX } from './asynciterablex';
 import { OperatorAsyncFunction, UnaryFunction } from '../interfaces';
 import { Transform, TransformCallback, TransformOptions } from 'stream';
 
-export interface AsyncIterableTransform<T> extends AsyncIterableX<T>, Transform {
+export interface AsyncIterableTransform<T>
+  extends AsyncIterableX<T>,
+    NodeJS.ReadableStream,
+    NodeJS.WritableStream {
+  new (options?: TransformOptions): AsyncIterableTransform<T>;
   pipe<R>(...operations: UnaryFunction<AsyncIterable<T>, R>[]): R;
   pipe<R>(...operations: OperatorAsyncFunction<T, R>[]): AsyncIterableX<R>;
   pipe<R extends NodeJS.WritableStream>(writable: R, options?: { end?: boolean }): R;
-  [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+  [Symbol.asyncIterator](): AsyncIterableIterator<any>;
 }
 
 const asyncIterableMixin = Symbol('asyncIterableMixin');
 
-export class AsyncIterableTransform<T> extends Transform {
-  private static [asyncIterableMixin] = false;
-  constructor(options?: TransformOptions) {
-    super(options);
-    // If this is the first time AsyncIterableTransform is being constructed,
-    // mixin the methods from the AsyncIterableX's prototype.
-    if (!AsyncIterableTransform[asyncIterableMixin]) {
-      AsyncIterableTransform[asyncIterableMixin] = true;
-      Object.defineProperties(
-        AsyncIterableTransform.prototype,
-        Object.getOwnPropertyDescriptors(AsyncIterableX.prototype)
-      );
-    }
-  }
-  /** @nocollapse */
-  _flush(callback: TransformCallback): void {
-    callback();
-  }
-  /** @nocollapse */
-  _transform(chunk: any, _encoding: string, callback: TransformCallback): void {
-    callback(null, chunk);
+export function AsyncIterableTransform<T>(
+  this: AsyncIterableTransform<T>,
+  options?: TransformOptions
+) {
+  Transform.call(this as any, options);
+  // If this is the first time AsyncIterableTransform is being constructed,
+  // mixin the methods from the AsyncIterableX's prototype.
+  if (!AsyncIterableTransform[asyncIterableMixin]) {
+    AsyncIterableTransform[asyncIterableMixin] = true;
+    Object.defineProperties(
+      AsyncIterableTransform.prototype,
+      Object.getOwnPropertyDescriptors(AsyncIterableX.prototype)
+    );
   }
 }
 
+AsyncIterableTransform.prototype = Object.create(Transform.prototype);
+
+AsyncIterableTransform[asyncIterableMixin] = false;
+
+/** @nocollapse */
+AsyncIterableTransform.prototype._flush = function (callback: TransformCallback): void {
+  callback();
+};
+/** @nocollapse */
+AsyncIterableTransform.prototype._transform = function (
+  chunk: any,
+  _encoding: string,
+  callback: TransformCallback
+): void {
+  callback(null, chunk);
+};
+
 export function asAsyncIterable<T>(options: TransformOptions = {}) {
-  return new AsyncIterableTransform<T>(options);
+  return Reflect.construct(AsyncIterableTransform, [options]) as AsyncIterableTransform<T>;
 }

src/asynciterable/fromdomstream.ts

@@ -63,15 +63,15 @@ async function* _consumeReader<T>(
 
 /** @ignore */
 async function* defaultReaderToAsyncIterator<T = any>(reader: ReadableStreamDefaultReader<T>) {
-  let r: ReadableStreamDefaultReadResult<T>;
+  let r: ReadableStreamReadResult<T>;
   while (!(r = await reader.read()).done) {
     yield r.value;
   }
 }
 
 /** @ignore */
 async function* byobReaderToAsyncIterator(reader: ReadableStreamReader<Uint8Array>) {
-  let r: ReadableStreamDefaultReadResult<Uint8Array>;
+  let r: ReadableStreamReadResult<Uint8Array>;
   let value: number | ArrayBufferLike = yield null!;
   while (!(r = await readNext(reader, value, 0)).done) {
     value = yield r.value;
@@ -83,7 +83,7 @@ async function readNext(
   reader: ReadableStreamReader<Uint8Array>,
   bufferOrLen: ArrayBufferLike | number,
   offset: number
-): Promise<ReadableStreamDefaultReadResult<Uint8Array>> {
+): Promise<ReadableStreamReadResult<Uint8Array>> {
   let size: number;
   let buffer: ArrayBufferLike;
 
@@ -106,7 +106,7 @@ async function readInto(
   buffer: ArrayBufferLike,
   offset: number,
   size: number
-): Promise<ReadableStreamDefaultReadResult<Uint8Array>> {
+): Promise<ReadableStreamReadResult<Uint8Array>> {
   let innerOffset = offset;
   if (innerOffset >= size) {
     return { done: false, value: new Uint8Array(buffer, 0, size) };

src/asynciterable/operators/withabort.ts

@@ -16,6 +16,7 @@ export class WithAbortAsyncIterable<TSource> extends AsyncIterableX<TSource> {
   }
 
   [Symbol.asyncIterator](): AsyncIterator<TSource> {
+    // @ts-ignore
     return this._source[Symbol.asyncIterator](this._signal);
   }
 }

src/asynciterable/todomstream.ts

@@ -49,12 +49,12 @@ class UnderlyingAsyncIterableDefaultSource<TSource = any> extends AbstractUnderl
     super(source);
   }
   // eslint-disable-next-line consistent-return
-  async pull(controller: ReadableStreamDefaultController<TSource>) {
+  async pull(controller: ReadableStreamController<TSource>) {
     const source = this._source;
     if (source) {
       const r = await source.next(controller.desiredSize);
       if (!r.done) {
-        return controller.enqueue(r.value);
+        return (controller as ReadableStreamDefaultController<TSource>).enqueue(r.value);
       }
     }
     controller.close();
@@ -85,7 +85,9 @@ class UnderlyingAsyncIterableByteSource<TSource extends ArrayBufferView = Uint8A
   // eslint-disable-next-line consistent-return
   async pull(controller: ReadableStreamController<TSource>) {
     if (!(controller as any).byobRequest) {
-      return await this.fallbackDefaultSource.pull(controller);
+      return await this.fallbackDefaultSource.pull(
+        controller as ReadableStreamDefaultController<TSource>
+      );
     }
     if (this._source) {
       const { view } = (controller as any).byobRequest;