Merge pull request #89 from MattiasBuelens/type-only-imports

Consistently use type-only imports when possible

.eslintrc.json

@@ -232,7 +232,7 @@
     "no-confusing-arrow": "off",
     "no-const-assign": "error",
     "no-dupe-class-members": "off", // incompatible with method overload signatures
-    "no-duplicate-imports": "error",
+    "no-duplicate-imports": "off", // replaced with @typescript-eslint/no-duplicate-imports below
     "no-new-symbol": "error",
     "no-this-before-super": "error",
     "no-useless-computed-key": "error",
@@ -270,6 +270,8 @@
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-non-null-assertion": "off",
     "@typescript-eslint/no-use-before-define": "off",
-    "@typescript-eslint/no-useless-constructor": "error"
+    "@typescript-eslint/no-useless-constructor": "error",
+    "@typescript-eslint/no-duplicate-imports": "error",
+    "@typescript-eslint/consistent-type-imports": "error"
   }
 }

src/lib/abstract-ops/queuing-strategy.ts

@@ -1,4 +1,4 @@
-import { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';
+import type { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';
 import NumberIsNaN from '../../stub/number-isnan';
 
 export function ExtractHighWaterMark(strategy: QueuingStrategy, defaultHWM: number): number {

src/lib/byte-length-queuing-strategy.ts

@@ -1,4 +1,4 @@
-import { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';
+import type { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';
 import { typeIsObject } from './helpers/miscellaneous';
 import { assertRequiredArgument } from './validators/basic';
 import { convertQueuingStrategyInit } from './validators/queuing-strategy-init';

src/lib/count-queuing-strategy.ts

@@ -1,4 +1,4 @@
-import { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';
+import type { QueuingStrategy, QueuingStrategyInit } from './queuing-strategy';
 import { typeIsObject } from './helpers/miscellaneous';
 import { assertRequiredArgument } from './validators/basic';
 import { convertQueuingStrategyInit } from './validators/queuing-strategy-init';

src/lib/readable-stream.ts

@@ -5,7 +5,7 @@ import {
   setPromiseIsHandledToTrue,
   transformPromiseWith
 } from './helpers/webidl';
-import { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';
+import type { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';
 import { AcquireReadableStreamAsyncIterator, ReadableStreamAsyncIterator } from './readable-stream/async-iterator';
 import { defaultReaderClosedPromiseReject, defaultReaderClosedPromiseResolve } from './readable-stream/generic-reader';
 import {
@@ -22,7 +22,8 @@ import {
 } from './readable-stream/byob-reader';
 import { ReadableStreamPipeTo } from './readable-stream/pipe';
 import { ReadableStreamTee } from './readable-stream/tee';
-import { IsWritableStream, IsWritableStreamLocked, WritableStream } from './writable-stream';
+import type { WritableStream } from './writable-stream';
+import { IsWritableStream, IsWritableStreamLocked } from './writable-stream';
 import { SimpleQueue } from './simple-queue';
 import {
   ReadableByteStreamController,
@@ -53,9 +54,10 @@ import { assertObject, assertRequiredArgument } from './validators/basic';
 import { convertQueuingStrategy } from './validators/queuing-strategy';
 import { ExtractHighWaterMark, ExtractSizeAlgorithm } from './abstract-ops/queuing-strategy';
 import { convertUnderlyingDefaultOrByteSource } from './validators/underlying-source';
-import { ReadableStreamGetReaderOptions } from './readable-stream/reader-options';
+import type { ReadableStreamGetReaderOptions } from './readable-stream/reader-options';
 import { convertReaderOptions } from './validators/reader-options';
-import { StreamPipeOptions, ValidatedStreamPipeOptions } from './readable-stream/pipe-options';
+import type { ValidatedStreamPipeOptions } from './readable-stream/pipe-options';
+import { StreamPipeOptions } from './readable-stream/pipe-options';
 import { ReadableStreamIteratorOptions } from './readable-stream/iterator-options';
 import { convertIteratorOptions } from './validators/iterator-options';
 import { convertPipeOptions } from './validators/pipe-options';

src/lib/readable-stream/async-iterator.ts

@@ -1,13 +1,8 @@
 /// <reference lib="es2018.asynciterable" />
 
-import { ReadableStream } from '../readable-stream';
-import {
-  AcquireReadableStreamDefaultReader,
-  ReadableStreamDefaultReader,
-  ReadableStreamDefaultReaderRead,
-  ReadableStreamDefaultReadResult,
-  ReadRequest
-} from './default-reader';
+import type { ReadableStream } from '../readable-stream';
+import type { ReadableStreamDefaultReader, ReadableStreamDefaultReadResult, ReadRequest } from './default-reader';
+import { AcquireReadableStreamDefaultReader, ReadableStreamDefaultReaderRead } from './default-reader';
 import {
   ReadableStreamReaderGenericCancel,
   ReadableStreamReaderGenericRelease,

src/lib/readable-stream/byob-reader.ts

@@ -6,12 +6,10 @@ import {
   ReadableStreamReaderGenericRelease,
   readerLockException
 } from './generic-reader';
-import { IsReadableStreamLocked, ReadableByteStream, ReadableStream } from '../readable-stream';
-import {
-  IsReadableByteStreamController,
-  ReadableByteStreamController,
-  ReadableByteStreamControllerPullInto
-} from './byte-stream-controller';
+import type { ReadableByteStream, ReadableStream } from '../readable-stream';
+import { IsReadableStreamLocked } from '../readable-stream';
+import type { ReadableByteStreamController } from './byte-stream-controller';
+import { IsReadableByteStreamController, ReadableByteStreamControllerPullInto } from './byte-stream-controller';
 import { typeIsObject } from '../helpers/miscellaneous';
 import { newPromise, promiseRejectedWith } from '../helpers/webidl';
 import { assertRequiredArgument } from '../validators/basic';

src/lib/readable-stream/byte-stream-controller.ts

@@ -1,28 +1,24 @@
 import assert from '../../stub/assert';
 import { SimpleQueue } from '../simple-queue';
 import { ResetQueue } from '../abstract-ops/queue-with-sizes';
+import type { ReadRequest } from './default-reader';
 import {
   ReadableStreamAddReadRequest,
   ReadableStreamFulfillReadRequest,
   ReadableStreamGetNumReadRequests,
-  ReadableStreamHasDefaultReader,
-  ReadRequest
+  ReadableStreamHasDefaultReader
 } from './default-reader';
+import type { ReadIntoRequest } from './byob-reader';
 import {
   ReadableStreamAddReadIntoRequest,
   ReadableStreamFulfillReadIntoRequest,
   ReadableStreamGetNumReadIntoRequests,
-  ReadableStreamHasBYOBReader,
-  ReadIntoRequest
+  ReadableStreamHasBYOBReader
 } from './byob-reader';
 import NumberIsInteger from '../../stub/number-isinteger';
-import {
-  IsReadableStreamLocked,
-  ReadableByteStream,
-  ReadableStreamClose,
-  ReadableStreamError
-} from '../readable-stream';
-import { ValidatedUnderlyingByteSource } from './underlying-source';
+import type { ReadableByteStream } from '../readable-stream';
+import { IsReadableStreamLocked, ReadableStreamClose, ReadableStreamError } from '../readable-stream';
+import type { ValidatedUnderlyingByteSource } from './underlying-source';
 import { typeIsObject } from '../helpers/miscellaneous';
 import {
   ArrayBufferSlice,

src/lib/readable-stream/default-controller.ts

@@ -1,15 +1,17 @@
-import { QueuingStrategySizeCallback } from '../queuing-strategy';
+import type { QueuingStrategySizeCallback } from '../queuing-strategy';
 import assert from '../../stub/assert';
-import { DequeueValue, EnqueueValueWithSize, QueuePair, ResetQueue } from '../abstract-ops/queue-with-sizes';
+import type { QueuePair } from '../abstract-ops/queue-with-sizes';
+import { DequeueValue, EnqueueValueWithSize, ResetQueue } from '../abstract-ops/queue-with-sizes';
+import type { ReadRequest } from './default-reader';
 import {
   ReadableStreamAddReadRequest,
   ReadableStreamFulfillReadRequest,
-  ReadableStreamGetNumReadRequests,
-  ReadRequest
+  ReadableStreamGetNumReadRequests
 } from './default-reader';
-import { SimpleQueue } from '../simple-queue';
-import { IsReadableStreamLocked, ReadableStream, ReadableStreamClose, ReadableStreamError } from '../readable-stream';
-import { ValidatedUnderlyingSource } from './underlying-source';
+import type { SimpleQueue } from '../simple-queue';
+import type { ReadableStream } from '../readable-stream';
+import { IsReadableStreamLocked, ReadableStreamClose, ReadableStreamError } from '../readable-stream';
+import type { ValidatedUnderlyingSource } from './underlying-source';
 import { typeIsObject } from '../helpers/miscellaneous';
 import { CancelSteps, PullSteps } from '../abstract-ops/internal-methods';
 import { promiseResolvedWith, uponPromise } from '../helpers/webidl';

src/lib/readable-stream/default-reader.ts

@@ -6,7 +6,8 @@ import {
   ReadableStreamReaderGenericRelease,
   readerLockException
 } from './generic-reader';
-import { IsReadableStreamLocked, ReadableStream } from '../readable-stream';
+import type { ReadableStream } from '../readable-stream';
+import { IsReadableStreamLocked } from '../readable-stream';
 import { typeIsObject } from '../helpers/miscellaneous';
 import { PullSteps } from '../abstract-ops/internal-methods';
 import { newPromise, promiseRejectedWith } from '../helpers/webidl';

src/lib/readable-stream/generic-reader.ts

@@ -1,5 +1,6 @@
 import assert from '../../stub/assert';
-import { ReadableStream, ReadableStreamCancel, ReadableStreamReader } from '../readable-stream';
+import type { ReadableStream, ReadableStreamReader } from '../readable-stream';
+import { ReadableStreamCancel } from '../readable-stream';
 import { newPromise, setPromiseIsHandledToTrue } from '../helpers/webidl';
 
 export function ReadableStreamReaderGenericInitialize<R>(reader: ReadableStreamReader<R>, stream: ReadableStream<R>) {

src/lib/readable-stream/pipe-options.ts

@@ -1,4 +1,4 @@
-import { AbortSignal } from '../abort-signal';
+import type { AbortSignal } from '../abort-signal';
 
 /**
  * Options for {@link ReadableStream.pipeTo | piping} a stream.

src/lib/readable-stream/pipe.ts

@@ -1,11 +1,12 @@
-import { IsReadableStream, IsReadableStreamLocked, ReadableStream, ReadableStreamCancel } from '../readable-stream';
+import type { ReadableStream } from '../readable-stream';
+import { IsReadableStream, IsReadableStreamLocked, ReadableStreamCancel } from '../readable-stream';
 import { AcquireReadableStreamDefaultReader, ReadableStreamDefaultReaderRead } from './default-reader';
 import { ReadableStreamReaderGenericRelease } from './generic-reader';
+import type { WritableStream } from '../writable-stream';
 import {
   AcquireWritableStreamDefaultWriter,
   IsWritableStream,
   IsWritableStreamLocked,
-  WritableStream,
   WritableStreamAbort,
   WritableStreamCloseQueuedOrInFlight,
   WritableStreamDefaultWriterCloseWithErrorPropagation,
@@ -23,7 +24,8 @@ import {
   uponRejection
 } from '../helpers/webidl';
 import { noop } from '../../utils';
-import { AbortSignal, isAbortSignal } from '../abort-signal';
+import type { AbortSignal } from '../abort-signal';
+import { isAbortSignal } from '../abort-signal';
 import { DOMException } from '../../stub/dom-exception';
 
 export function ReadableStreamPipeTo<T>(source: ReadableStream<T>,

src/lib/readable-stream/readable-writable-pair.ts

@@ -1,5 +1,5 @@
-import { ReadableStream } from '../readable-stream';
-import { WritableStream } from '../writable-stream';
+import type { ReadableStream } from '../readable-stream';
+import type { WritableStream } from '../writable-stream';
 
 /**
  * A pair of a {@link ReadableStream | readable stream} and {@link WritableStream | writable stream} that can be passed

src/lib/readable-stream/tee.ts

@@ -1,29 +1,27 @@
+import type { ReadableByteStream, ReadableStream, ReadableStreamReader } from '../readable-stream';
 import {
   CreateReadableByteStream,
   CreateReadableStream,
   IsReadableStream,
-  ReadableByteStream,
-  ReadableStream,
-  ReadableStreamCancel,
-  ReadableStreamReader
+  ReadableStreamCancel
 } from '../readable-stream';
 import { ReadableStreamReaderGenericRelease } from './generic-reader';
+import type { ReadRequest } from './default-reader';
 import {
   AcquireReadableStreamDefaultReader,
   IsReadableStreamDefaultReader,
-  ReadableStreamDefaultReaderRead,
-  ReadRequest
+  ReadableStreamDefaultReaderRead
 } from './default-reader';
+import type { ReadIntoRequest } from './byob-reader';
 import {
   AcquireReadableStreamBYOBReader,
   IsReadableStreamBYOBReader,
-  ReadableStreamBYOBReaderRead,
-  ReadIntoRequest
+  ReadableStreamBYOBReaderRead
 } from './byob-reader';
 import assert from '../../stub/assert';
 import { newPromise, promiseResolvedWith, queueMicrotask, uponRejection } from '../helpers/webidl';
+import type { ReadableStreamDefaultController } from './default-controller';
 import {
-  ReadableStreamDefaultController,
   ReadableStreamDefaultControllerClose,
   ReadableStreamDefaultControllerEnqueue,
   ReadableStreamDefaultControllerError

src/lib/readable-stream/underlying-source.ts

@@ -1,5 +1,5 @@
-import { ReadableStreamDefaultController } from './default-controller';
-import { ReadableByteStreamController } from './byte-stream-controller';
+import type { ReadableStreamDefaultController } from './default-controller';
+import type { ReadableByteStreamController } from './byte-stream-controller';
 
 export type ReadableStreamController<R = any> =
   ReadableStreamDefaultController<R> | ReadableByteStreamController;

src/lib/transform-stream.ts

@@ -1,6 +1,7 @@
 import assert from '../stub/assert';
 import { newPromise, promiseRejectedWith, promiseResolvedWith, transformPromiseWith } from './helpers/webidl';
-import { CreateReadableStream, ReadableStream, ReadableStreamDefaultController } from './readable-stream';
+import type { ReadableStream, ReadableStreamDefaultController } from './readable-stream';
+import { CreateReadableStream } from './readable-stream';
 import {
   ReadableStreamDefaultControllerCanCloseOrEnqueue,
   ReadableStreamDefaultControllerClose,
@@ -9,18 +10,19 @@ import {
   ReadableStreamDefaultControllerGetDesiredSize,
   ReadableStreamDefaultControllerHasBackpressure
 } from './readable-stream/default-controller';
-import { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';
-import { CreateWritableStream, WritableStream, WritableStreamDefaultControllerErrorIfNeeded } from './writable-stream';
+import type { QueuingStrategy, QueuingStrategySizeCallback } from './queuing-strategy';
+import type { WritableStream } from './writable-stream';
+import { CreateWritableStream, WritableStreamDefaultControllerErrorIfNeeded } from './writable-stream';
 import { typeIsObject } from './helpers/miscellaneous';
 import { IsNonNegativeNumber } from './abstract-ops/miscellaneous';
 import { convertQueuingStrategy } from './validators/queuing-strategy';
 import { ExtractHighWaterMark, ExtractSizeAlgorithm } from './abstract-ops/queuing-strategy';
+import type { ValidatedTransformer } from './transform-stream/transformer';
 import {
   Transformer,
   TransformerFlushCallback,
   TransformerStartCallback,
-  TransformerTransformCallback,
-  ValidatedTransformer
+  TransformerTransformCallback
 } from './transform-stream/transformer';
 import { convertTransformer } from './validators/transformer';
 

src/lib/transform-stream/transformer.ts

@@ -1,4 +1,4 @@
-import { TransformStreamDefaultController } from '../transform-stream';
+import type { TransformStreamDefaultController } from '../transform-stream';
 
 /** @public */
 export type TransformerStartCallback<O>

src/lib/validators/iterator-options.ts

@@ -1,5 +1,5 @@
 import { assertDictionary } from './basic';
-import {
+import type {
   ReadableStreamIteratorOptions,
   ValidatedReadableStreamIteratorOptions
 } from '../readable-stream/iterator-options';

src/lib/validators/pipe-options.ts

@@ -1,6 +1,7 @@
 import { assertDictionary } from './basic';
-import { StreamPipeOptions, ValidatedStreamPipeOptions } from '../readable-stream/pipe-options';
-import { AbortSignal, isAbortSignal } from '../abort-signal';
+import type { StreamPipeOptions, ValidatedStreamPipeOptions } from '../readable-stream/pipe-options';
+import type { AbortSignal } from '../abort-signal';
+import { isAbortSignal } from '../abort-signal';
 
 export function convertPipeOptions(options: StreamPipeOptions | null | undefined,
                                    context: string): ValidatedStreamPipeOptions {

src/lib/validators/queuing-strategy-init.ts

@@ -1,4 +1,4 @@
-import { QueuingStrategyInit } from '../queuing-strategy';
+import type { QueuingStrategyInit } from '../queuing-strategy';
 import { assertDictionary, assertRequiredField, convertUnrestrictedDouble } from './basic';
 
 export function convertQueuingStrategyInit(init: QueuingStrategyInit | null | undefined,

src/lib/validators/queuing-strategy.ts

@@ -1,4 +1,4 @@
-import { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';
+import type { QueuingStrategy, QueuingStrategySizeCallback } from '../queuing-strategy';
 import { assertDictionary, assertFunction, convertUnrestrictedDouble } from './basic';
 
 export function convertQueuingStrategy<T>(init: QueuingStrategy<T> | null | undefined,

src/lib/validators/readable-stream.ts

@@ -1,4 +1,5 @@
-import { IsReadableStream, ReadableStream } from '../readable-stream';
+import type { ReadableStream } from '../readable-stream';
+import { IsReadableStream } from '../readable-stream';
 
 export function assertReadableStream(x: unknown, context: string): asserts x is ReadableStream {
   if (!IsReadableStream(x)) {

src/lib/validators/readable-writable-pair.ts

@@ -1,6 +1,6 @@
 import { assertDictionary, assertRequiredField } from './basic';
-import { ReadableStream } from '../readable-stream';
-import { WritableStream } from '../writable-stream';
+import type { ReadableStream } from '../readable-stream';
+import type { WritableStream } from '../writable-stream';
 import { assertReadableStream } from './readable-stream';
 import { assertWritableStream } from './writable-stream';
 

src/lib/validators/reader-options.ts

@@ -1,5 +1,5 @@
 import { assertDictionary } from './basic';
-import { ReadableStreamGetReaderOptions } from '../readable-stream/reader-options';
+import type { ReadableStreamGetReaderOptions } from '../readable-stream/reader-options';
 
 export function convertReaderOptions(options: ReadableStreamGetReaderOptions | null | undefined,
                                      context: string): ReadableStreamGetReaderOptions {

src/lib/validators/transformer.ts

@@ -1,13 +1,13 @@
 import { assertDictionary, assertFunction } from './basic';
 import { promiseCall, reflectCall } from '../helpers/webidl';
-import {
+import type {
   Transformer,
   TransformerFlushCallback,
   TransformerStartCallback,
   TransformerTransformCallback,
   ValidatedTransformer
 } from '../transform-stream/transformer';
-import { TransformStreamDefaultController } from '../transform-stream';
+import type { TransformStreamDefaultController } from '../transform-stream';
 
 export function convertTransformer<I, O>(original: Transformer<I, O> | null,
                                          context: string): ValidatedTransformer<I, O> {

src/lib/validators/underlying-sink.ts

@@ -1,14 +1,14 @@
 import { assertDictionary, assertFunction } from './basic';
 import { promiseCall, reflectCall } from '../helpers/webidl';
-import {
+import type {
   UnderlyingSink,
   UnderlyingSinkAbortCallback,
   UnderlyingSinkCloseCallback,
   UnderlyingSinkStartCallback,
   UnderlyingSinkWriteCallback,
   ValidatedUnderlyingSink
 } from '../writable-stream/underlying-sink';
-import { WritableStreamDefaultController } from '../writable-stream';
+import type { WritableStreamDefaultController } from '../writable-stream';
 
 export function convertUnderlyingSink<W>(original: UnderlyingSink<W> | null,
                                          context: string): ValidatedUnderlyingSink<W> {

src/lib/validators/underlying-source.ts

@@ -1,5 +1,5 @@
 import { assertDictionary, assertFunction, convertUnsignedLongLongWithEnforceRange } from './basic';
-import {
+import type {
   ReadableStreamController,
   UnderlyingByteSource,
   UnderlyingDefaultOrByteSource,