@tstdl/base 0.93.36 → 0.93.38

package/source/utils/stream/finalize-stream.ts

@@ -1,68 +0,0 @@
-import { isFunction } from '../type-guards.js';
-
-export type ReadableStreamFinalizeEvent =
-  | { type: 'done' }
-  | { type: 'error', error: any }
-  | { type: 'cancel', reason: any };
-
-/**
- * Finalizer is called *after* the specific event occurred.
- */
-export type StreamFinalizerHandler = (event: ReadableStreamFinalizeEvent) => void | Promise<void>;
-
-export type FinalizeStreamHandlers = {
-  finalizer?: StreamFinalizerHandler,
-  beforeDone?(): void | Promise<void>,
-  done?(): void | Promise<void>,
-  error?(error: Error): void | Promise<void>,
-  beforeCancel?(reason: any): void | Promise<void>,
-  cancel?(reason: any): void | Promise<void>
-};
-
-export function finalizeStream<T>(stream: ReadableStream<T>, finalizerOrHandlers: StreamFinalizerHandler | FinalizeStreamHandlers): ReadableStream<T> {
-  const handlers: FinalizeStreamHandlers = isFunction(finalizerOrHandlers) ? { finalizer: finalizerOrHandlers } : finalizerOrHandlers;
-
-  let reader: ReadableStreamDefaultReader<T>;
-
-  return new ReadableStream<T>({
-    start() {
-      reader = stream.getReader();
-    },
-    async pull(controller) {
-      let chunk: ReadableStreamReadResult<T>;
-
-      try {
-        chunk = await reader.read();
-      }
-      catch (error) {
-        await handlers.error?.(error as Error);
-        await handlers.finalizer?.({ type: 'error', error });
-        throw error;
-      }
-
-      if (chunk.done) {
-        await handlers.beforeDone?.();
-        controller.close();
-        await handlers.done?.();
-        await handlers.finalizer?.({ type: 'done' });
-      }
-      else {
-        controller.enqueue(chunk.value);
-      }
-    },
-    async cancel(reason) {
-      try {
-        await handlers.beforeCancel?.(reason);
-        await reader.cancel(reason);
-        await handlers.cancel?.(reason);
-      }
-      catch (error) {
-        await handlers.error?.(error as Error);
-        throw error;
-      }
-      finally {
-        await handlers.finalizer?.({ type: 'cancel', reason });
-      }
-    }
-  });
-}

package/source/utils/stream/from-promise.ts

@@ -1,34 +0,0 @@
-import { resolveValueOrProvider, type ValueOrProvider } from '../value-or-provider.js';
-
-export function readableStreamFromPromise<T>(promiseOrProvider: ValueOrProvider<Promise<ReadableStream<T>>>): ReadableStream<T> {
-  const stream = new TransformStream<T, T>();
-
-  resolveValueOrProvider(promiseOrProvider)
-    .then(async (readable) => readable.pipeTo(stream.writable))
-    .catch(async (error: unknown) => stream.writable.abort(error).catch(() => { /* noop */ }));
-
-  return stream.readable;
-}
-
-export function transformStreamFromPromise<I, O>(promiseOrProvider: ValueOrProvider<Promise<TransformStream<I, O>>>): TransformStream<I, O> {
-  const incoming = new TransformStream<I, I>();
-  const outgoing = new TransformStream<O, O>();
-
-  void (async () => {
-    try {
-      const sourceTransformer = await resolveValueOrProvider(promiseOrProvider);
-
-      await incoming.readable.pipeTo(sourceTransformer.writable);
-      await sourceTransformer.readable.pipeTo(outgoing.writable);
-    }
-    catch (e) {
-      await incoming.writable.abort(e).catch(() => { /* noop */ });
-      await outgoing.writable.abort(e).catch(() => { /* noop */ });
-    }
-  })();
-
-  return {
-    writable: incoming.writable,
-    readable: outgoing.readable,
-  };
-}

package/source/utils/stream/index.ts

@@ -1,9 +0,0 @@
-export * from './finalize-stream.js';
-export * from './readable-stream-adapter.js';
-export * from './from-promise.js';
-export * from './size-limited-stream.js';
-export * from './slice.js';
-export * from './stream-helper-types.js';
-export * from './stream-reader.js';
-export * from './to-bytes-stream.js';
-export * from './to-readable-stream.js';

package/source/utils/stream/readable-stream-adapter.ts

@@ -1,46 +0,0 @@
-import type { AnyIterable } from '../any-iterable-iterator.js';
-import { isAsyncIterable } from '../async-iterable-helpers/is-async-iterable.js';
-
-export async function* getReadableStreamIterable<T>(stream: ReadableStream<T>, { close = true }: { close?: boolean } = {}): AsyncIterable<T> {
-  const reader = stream.getReader();
-
-  try {
-    while (true) {
-      const result = await reader.read();
-
-      if (result.done) {
-        return;
-      }
-
-      yield result.value;
-    }
-  }
-  finally {
-    if (close) {
-      await reader.cancel();
-    }
-    else {
-      reader.releaseLock();
-    }
-  }
-}
-
-export function getReadableStreamFromIterable<T>(iterable: AnyIterable<T>): ReadableStream<T> {
-  const iterator = isAsyncIterable(iterable) ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
-
-  return new ReadableStream({
-    pull: async (controller) => {
-      const result = await iterator.next();
-
-      if (result.done == true) {
-        controller.close();
-      }
-      else {
-        controller.enqueue(result.value);
-      }
-    },
-    cancel: async (reason) => {
-      await iterator.return?.(reason);
-    }
-  });
-}

package/source/utils/stream/size-limited-stream.ts

@@ -1,18 +0,0 @@
-import { MaxBytesExceededError } from '#/errors/max-bytes-exceeded.error.js';
-import type { BinaryData } from '#/types/index.js';
-
-export function sizeLimitTransform<T extends BinaryData>(maxBytes: number, writableStrategy?: QueuingStrategy<T>, readableStrategy?: QueuingStrategy<T>): TransformStream<T, T> {
-  let totalLength = 0;
-
-  return new TransformStream({
-    transform(chunk, controller) {
-      totalLength += chunk.byteLength;
-
-      if (totalLength > maxBytes) {
-        throw MaxBytesExceededError.fromBytes(maxBytes);
-      }
-
-      controller.enqueue(chunk);
-    },
-  }, writableStrategy, readableStrategy);
-}

package/source/utils/stream/slice.ts

@@ -1,97 +0,0 @@
-import { assert } from '../type-guards.js';
-import { kibibyte, mebibyte } from '../units.js';
-import { toBytesStream } from './to-bytes-stream.js';
-
-export function sliceStream(stream: ReadableStream<ArrayBufferView>, offset: number, length: number, type?: 'bytes'): ReadableStream<Uint8Array>;
-export function sliceStream<T>(stream: ReadableStream<T>, offset: number, length: number, type: 'chunks'): ReadableStream<T>;
-export function sliceStream<T>(stream: ReadableStream<T>, offset: number, length: number, type: 'chunks' | 'bytes' = 'bytes'): ReadableStream<T> {
-  assert(length > 0, 'Length must be positive');
-
-  let chunksRead = 0;
-
-  if (type == 'chunks') {
-    const reader = stream.getReader();
-
-    return new ReadableStream<T>({
-      async pull(controller) {
-        while (chunksRead < offset) {
-          const result = await reader.read();
-          chunksRead++;
-
-          if (result.done) {
-            controller.close();
-            return;
-          }
-        }
-
-        if ((chunksRead - offset) == length) {
-          await reader.cancel();
-          controller.close();
-          return;
-        }
-
-        const result = await reader.read();
-        chunksRead++;
-
-        if (result.done) {
-          controller.close();
-          return;
-        }
-
-        controller.enqueue(result.value);
-      },
-      async cancel(reason) {
-        await reader.cancel(reason);
-      },
-    });
-  }
-
-  const byobReader = toBytesStream(stream as ReadableStream<ArrayBufferView<ArrayBuffer>>).getReader({ mode: 'byob' });
-  let bytesRead = 0;
-
-  let offsetBuffer: ArrayBuffer | null = new ArrayBuffer(mebibyte);
-
-  return new ReadableStream({
-    type: 'bytes',
-    autoAllocateChunkSize: 100 * kibibyte,
-    async pull(controller) {
-      while (bytesRead < offset) {
-        const readResult = await byobReader.read(new Uint8Array(offsetBuffer!, 0, Math.min(offsetBuffer!.byteLength, offset - bytesRead)));
-
-        if (readResult.done) {
-          controller.close();
-          controller.byobRequest!.respond(0);
-          return;
-        }
-
-        bytesRead += readResult.value.byteLength;
-
-        if (bytesRead == offset) {
-          offsetBuffer = null;
-        }
-      }
-
-      if ((bytesRead - offset) == length) {
-        await byobReader.cancel();
-        controller.close();
-        controller.byobRequest!.respond(0);
-        return;
-      }
-
-      const view = controller.byobRequest!.view!;
-      const readResult = await byobReader.read(new Uint8Array(view.buffer, view.byteOffset, Math.min(view.byteLength, length - (bytesRead - offset))));
-
-      bytesRead += readResult.value!.byteLength;
-
-      if (readResult.done) {
-        await byobReader.cancel();
-        controller.close();
-      }
-
-      controller.byobRequest!.respondWithNewView(readResult.value!);
-    },
-    async cancel(reason) {
-      await byobReader.cancel(reason);
-    },
-  }) as ReadableStream<T>;
-}

package/source/utils/stream/stream-helper-types.ts

@@ -1,18 +0,0 @@
-declare const nonObjectBufferModeSymbol: unique symbol;
-declare const nonObjectStringModeSymbol: unique symbol;
-
-export type NonObjectMode = NonObjectBufferMode | NonObjectStringMode;
-
-export type NonObjectBufferMode = {
-  readonly [nonObjectBufferModeSymbol]: never
-};
-
-export type NonObjectStringMode = {
-  readonly [nonObjectStringModeSymbol]: never
-};
-
-export type NonObjectModeTypes = string | Buffer | Uint8Array;
-
-export type Data<T> = T extends NonObjectStringMode ? string
-  : T extends NonObjectBufferMode ? Buffer
-    : (T extends null ? never : T);

package/source/utils/stream/stream-reader.ts

@@ -1,169 +0,0 @@
-import { BadRequestError } from '#/errors/bad-request.error.js';
-import { MaxBytesExceededError } from '#/errors/max-bytes-exceeded.error.js';
-import { NotSupportedError } from '#/errors/not-supported.error.js';
-import type { AnyIterable } from '../any-iterable-iterator.js';
-import { isAsyncIterable } from '../async-iterable-helpers/is-async-iterable.js';
-import { concatArrayBufferViews } from '../binary.js';
-import { isDefined, isReadableStream } from '../type-guards.js';
-import { getReadableStreamFromIterable, getReadableStreamIterable } from './readable-stream-adapter.js';
-import { toBytesStream } from './to-bytes-stream.js';
-
-export type ReadBinaryStreamOptions = {
-  length?: number,
-
-  /** Action if source stream has more bytes than provided length */
-  onLengthExceed?: 'error' | 'close' | 'leave-open',
-
-  /** Action if source stream has less bytes than provided length */
-  onLengthSubceed?: 'error' | 'close' | 'leave-open',
-};
-
-export async function readBinaryStream(iterableOrStream: AnyIterable<ArrayBufferView> | ReadableStream<ArrayBufferView>, { length, onLengthExceed = 'error', onLengthSubceed = 'error' }: ReadBinaryStreamOptions = {}): Promise<Uint8Array<ArrayBuffer>> {
-  const stream = isReadableStream(iterableOrStream)
-    ? isDefined(length)
-      ? toBytesStream(iterableOrStream as ReadableStream<ArrayBufferView<ArrayBuffer>>)
-      : iterableOrStream
-    : getReadableStreamFromIterable(iterableOrStream);
-
-  if (isDefined(length)) {
-    const reader = stream.getReader({ mode: 'byob' });
-
-    let buffer = new ArrayBuffer(length + 1); // To read one extra byte for exceed detection
-    let bytesRead = 0;
-    let shouldCancelReaderAtEnd = true;
-
-    try {
-      while (true) {
-        const view = new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead);
-        const result = await reader.read(view);
-
-        buffer = result.value!.buffer;
-        bytesRead += result.value!.byteLength;
-
-        if (result.done) {
-          break;
-        }
-
-        // Check if we have read more data than the specified 'length'.
-        // This implies bytesRead is at least length + 1.
-        if (bytesRead > length) {
-          switch (onLengthExceed) {
-            case 'error':
-              await reader.cancel();
-              shouldCancelReaderAtEnd = false;
-              throw new MaxBytesExceededError('Size of stream is greater than provided length.');
-
-            case 'close':
-              await reader.cancel();
-              shouldCancelReaderAtEnd = false;
-              break;
-
-            case 'leave-open':
-              reader.releaseLock();
-              shouldCancelReaderAtEnd = false;
-              break;
-
-            default:
-              await reader.cancel();
-              shouldCancelReaderAtEnd = false;
-              throw new NotSupportedError(`Action ${onLengthExceed as string} not supported.`);
-          }
-          break;
-        }
-      }
-
-      if (bytesRead < length) { // Stream ended before specified length was read
-        switch (onLengthSubceed) {
-          case 'error':
-            if (shouldCancelReaderAtEnd) {
-              await reader.cancel();
-            }
-
-            shouldCancelReaderAtEnd = false;
-            throw new BadRequestError('Size of stream was less than provided length.');
-
-          case 'close':
-            if (shouldCancelReaderAtEnd) {
-              await reader.cancel();
-            }
-
-            shouldCancelReaderAtEnd = false;
-            break;
-
-          case 'leave-open':
-            if (shouldCancelReaderAtEnd) {
-              reader.releaseLock();
-            }
-
-            shouldCancelReaderAtEnd = false;
-            break;
-
-          default:
-            if (shouldCancelReaderAtEnd) {
-              await reader.cancel();
-            }
-
-            shouldCancelReaderAtEnd = false;
-            throw new NotSupportedError(`Action ${onLengthSubceed as string} not supported.`);
-        }
-      }
-
-      if (shouldCancelReaderAtEnd) {
-        await reader.cancel();
-      }
-
-      return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
-    }
-    catch (error) {
-      // If an error occurred (e.g., network, or thrown by logic above)
-      // and reader hasn't been handled, try to cancel it.
-      // This is a "best effort" cleanup.
-      if (shouldCancelReaderAtEnd && reader) {
-        try {
-          await reader.cancel(error); // Pass the error reason
-        }
-        catch { /* ignore */ }
-      }
-
-      throw error;
-    }
-  }
-
-  let totalLength = 0;
-  const reader = stream.getReader();
-  const views: ArrayBufferView[] = [];
-
-  while (true) {
-    const result = await reader.read();
-
-    if (result.done) {
-      if (isDefined(result.value)) {
-        views.push(result.value);
-        totalLength += result.value.byteLength;
-      }
-
-      break;
-    }
-
-    views.push(result.value);
-    totalLength += result.value.byteLength;
-  }
-
-  if (views.length == 0) {
-    return new Uint8Array(0);
-  }
-
-  return concatArrayBufferViews(views, totalLength);
-}
-
-export async function readTextStream(iterableOrStream: AsyncIterable<string> | ReadableStream<string>): Promise<string> {
-  const iterable = isAsyncIterable(iterableOrStream) ? iterableOrStream : getReadableStreamIterable(iterableOrStream);
-
-  let text = '';
-
-  for await (const chunk of iterable) {
-    text += chunk;
-  }
-
-  return text;
-}

package/source/utils/stream/to-bytes-stream.ts

@@ -1,97 +0,0 @@
-import { isNotNull, isNull } from '../type-guards.js';
-import { kibibyte } from '../units.js';
-
-export type ToBytesStreamOptions = {
-  ignoreCancel?: boolean,
-};
-
-export function toBytesStream(stream: ReadableStream<ArrayBufferView<ArrayBuffer>>, options?: ToBytesStreamOptions): ReadableStream<Uint8Array> {
-  try { // Try to use byob mode from source
-    let byobReader: ReadableStreamBYOBReader;
-
-    return new ReadableStream({
-      type: 'bytes',
-      autoAllocateChunkSize: 100 * kibibyte,
-      start() {
-        byobReader = stream.getReader({ mode: 'byob' });
-      },
-      async pull(controller) {
-        const readResult = await byobReader.read(controller.byobRequest!.view!);
-
-        if (readResult.done) {
-          controller.close();
-        }
-
-        controller.byobRequest!.respondWithNewView(readResult.value!);
-      },
-      async cancel(reason) {
-        if (options?.ignoreCancel == true) {
-          byobReader.releaseLock();
-        }
-        else {
-          await byobReader.cancel(reason);
-        }
-      },
-    });
-  }
-  catch { /* Ignore */ }
-
-  let reader: ReadableStreamDefaultReader<ArrayBufferView<ArrayBuffer>>;
-  let buffer: ArrayBufferView<ArrayBuffer> | null = null;
-
-  return new ReadableStream({
-    type: 'bytes',
-    start() {
-      reader = stream.getReader();
-    },
-    async pull(controller) {
-      const isByobRequest = isNotNull(controller.byobRequest);
-      const bufferIsEmpty = isNull(buffer) || (buffer.byteLength == 0);
-
-      if (!isByobRequest && !bufferIsEmpty) {
-        // We still have data left in buffer from previous pull which was byob
-        controller.enqueue(buffer!);
-        buffer = null;
-        return;
-      }
-
-      if (bufferIsEmpty) {
-        const readResult = await reader.read();
-
-        if (readResult.done) {
-          controller.close();
-          controller.byobRequest?.respond(0);
-          return;
-        }
-
-        buffer = readResult.value;
-      }
-
-      if (!isByobRequest) {
-        controller.enqueue(buffer!);
-        buffer = null;
-        return;
-      }
-
-      const targetView = controller.byobRequest.view!;
-      const targetArray = new Uint8Array(targetView.buffer, targetView.byteOffset, targetView.byteLength);
-
-      const setLength = Math.min(buffer!.byteLength, targetArray.byteLength);
-      const sourceArray = new Uint8Array(buffer!.buffer, buffer!.byteOffset, setLength);
-
-      targetArray.set(sourceArray);
-
-      buffer = new Uint8Array(buffer!.buffer, buffer!.byteOffset + setLength);
-
-      controller.byobRequest.respond(setLength);
-    },
-    async cancel(reason) {
-      if (options?.ignoreCancel == true) {
-        reader.releaseLock();
-      }
-      else {
-        await reader.cancel(reason);
-      }
-    },
-  });
-}

package/source/utils/stream/to-readable-stream.ts

@@ -1,8 +0,0 @@
-export function toReadableStream<T>(value: T): ReadableStream<T> {
-  return new ReadableStream<T>({
-    start(controller) {
-      controller.enqueue(value);
-      controller.close();
-    }
-  });
-}

package/source/utils/string/casing.ts

@@ -1,21 +0,0 @@
-import type { CamelCase, SnakeCase } from 'type-fest';
-
-const wordsPattern = /[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g;
-
-export function toSnakeCase<T extends string>(value: T): SnakeCase<T> {
-  const words = matchWords(value);
-  return words.map((word) => word.toLowerCase()).join('_') as SnakeCase<T>;
-}
-
-export function toCamelCase<T extends string>(value: T): CamelCase<T> {
-  const words = matchWords(value);
-
-  return words.reduce((acc, word, index) => {
-    const formattedWord = (index == 0) ? word.toLowerCase() : `${word[0]!.toUpperCase()}${word.slice(1)}`;
-    return acc + formattedWord;
-  }, '') as CamelCase<T>;
-}
-
-function matchWords(value: string): string[] {
-  return value.replace(/['\u2019]/g, '').match(wordsPattern) ?? [];
-}

package/source/utils/string/hypenate.ts

@@ -1,3 +0,0 @@
-export function hyphenate(value: string): string {
-  return value.replace(/[A-Z]|[0-9]+/ug, (match) => `-${match.toLowerCase()}`);
-}

package/source/utils/string/index.ts

@@ -1,5 +0,0 @@
-export * from './casing.js';
-export * from './hypenate.js';
-export * from './normalize.js';
-export * from './title-case.js';
-export * from './trim.js';