@pierre/storage 0.9.2 → 1.0.0

package/src/stream-utils.ts

@@ -2,254 +2,271 @@ import type { BlobLike, FileLike, ReadableStreamLike } from './types';
 
 type NodeBuffer = Uint8Array & { toString(encoding?: string): string };
 interface NodeBufferConstructor {
-	from(data: Uint8Array): NodeBuffer;
-	from(data: string, encoding?: string): NodeBuffer;
-	isBuffer(value: unknown): value is NodeBuffer;
+  from(data: Uint8Array): NodeBuffer;
+  from(data: string, encoding?: string): NodeBuffer;
+  isBuffer(value: unknown): value is NodeBuffer;
 }
 
 const BufferCtor: NodeBufferConstructor | undefined = (
-	globalThis as { Buffer?: NodeBufferConstructor }
+  globalThis as { Buffer?: NodeBufferConstructor }
 ).Buffer;
 
 export const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
 
 export type ChunkSegment = {
-	chunk: Uint8Array;
-	eof: boolean;
+  chunk: Uint8Array;
+  eof: boolean;
 };
 
-export async function* chunkify(source: AsyncIterable<Uint8Array>): AsyncIterable<ChunkSegment> {
-	let pending: Uint8Array | null = null;
-	let produced = false;
-
-	for await (const value of source) {
-		const bytes = value;
-
-		if (pending && pending.byteLength === MAX_CHUNK_BYTES) {
-			yield { chunk: pending, eof: false };
-			produced = true;
-			pending = null;
-		}
-
-		const merged: Uint8Array = pending ? concatChunks(pending, bytes) : bytes;
-		pending = null;
-
-		let cursor: Uint8Array = merged;
-		while (cursor.byteLength > MAX_CHUNK_BYTES) {
-			const chunk: Uint8Array = cursor.slice(0, MAX_CHUNK_BYTES);
-			cursor = cursor.slice(MAX_CHUNK_BYTES);
-			yield { chunk, eof: false };
-			produced = true;
-		}
-
-		pending = cursor;
-	}
-
-	if (pending) {
-		yield { chunk: pending, eof: true };
-		produced = true;
-	}
-
-	if (!produced) {
-		yield { chunk: new Uint8Array(0), eof: true };
-	}
+export async function* chunkify(
+  source: AsyncIterable<Uint8Array>
+): AsyncIterable<ChunkSegment> {
+  let pending: Uint8Array | null = null;
+  let produced = false;
+
+  for await (const value of source) {
+    const bytes = value;
+
+    if (pending && pending.byteLength === MAX_CHUNK_BYTES) {
+      yield { chunk: pending, eof: false };
+      produced = true;
+      pending = null;
+    }
+
+    const merged: Uint8Array = pending ? concatChunks(pending, bytes) : bytes;
+    pending = null;
+
+    let cursor: Uint8Array = merged;
+    while (cursor.byteLength > MAX_CHUNK_BYTES) {
+      const chunk: Uint8Array = cursor.slice(0, MAX_CHUNK_BYTES);
+      cursor = cursor.slice(MAX_CHUNK_BYTES);
+      yield { chunk, eof: false };
+      produced = true;
+    }
+
+    pending = cursor;
+  }
+
+  if (pending) {
+    yield { chunk: pending, eof: true };
+    produced = true;
+  }
+
+  if (!produced) {
+    yield { chunk: new Uint8Array(0), eof: true };
+  }
 }
 
 export async function* toAsyncIterable(
-	source:
-		| string
-		| Uint8Array
-		| ArrayBuffer
-		| BlobLike
-		| FileLike
-		| ReadableStreamLike<Uint8Array | ArrayBuffer | ArrayBufferView | string>
-		| AsyncIterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>
-		| Iterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>,
+  source:
+    | string
+    | Uint8Array
+    | ArrayBuffer
+    | BlobLike
+    | FileLike
+    | ReadableStreamLike<Uint8Array | ArrayBuffer | ArrayBufferView | string>
+    | AsyncIterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>
+    | Iterable<Uint8Array | ArrayBuffer | ArrayBufferView | string>
 ): AsyncIterable<Uint8Array> {
-	if (typeof source === 'string') {
-		yield new TextEncoder().encode(source);
-		return;
-	}
-	if (source instanceof Uint8Array) {
-		yield source;
-		return;
-	}
-	if (source instanceof ArrayBuffer) {
-		yield new Uint8Array(source);
-		return;
-	}
-	if (ArrayBuffer.isView(source)) {
-		yield new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-		return;
-	}
-	if (isBlobLike(source)) {
-		const stream = source.stream();
-		if (isAsyncIterable(stream)) {
-			for await (const chunk of stream as AsyncIterable<unknown>) {
-				yield ensureUint8Array(chunk);
-			}
-			return;
-		}
-		if (isReadableStreamLike(stream)) {
-			yield* readReadableStream(stream);
-			return;
-		}
-	}
-	if (isReadableStreamLike(source)) {
-		yield* readReadableStream(source);
-		return;
-	}
-	if (isAsyncIterable(source)) {
-		for await (const chunk of source as AsyncIterable<unknown>) {
-			yield ensureUint8Array(chunk);
-		}
-		return;
-	}
-	if (isIterable(source)) {
-		for (const chunk of source as Iterable<unknown>) {
-			yield ensureUint8Array(chunk);
-		}
-		return;
-	}
-	throw new Error('Unsupported content source; expected binary data');
+  if (typeof source === 'string') {
+    yield new TextEncoder().encode(source);
+    return;
+  }
+  if (source instanceof Uint8Array) {
+    yield source;
+    return;
+  }
+  if (source instanceof ArrayBuffer) {
+    yield new Uint8Array(source);
+    return;
+  }
+  if (ArrayBuffer.isView(source)) {
+    yield new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    return;
+  }
+  if (isBlobLike(source)) {
+    const stream = source.stream();
+    if (isAsyncIterable(stream)) {
+      for await (const chunk of stream as AsyncIterable<unknown>) {
+        yield ensureUint8Array(chunk);
+      }
+      return;
+    }
+    if (isReadableStreamLike(stream)) {
+      yield* readReadableStream(stream);
+      return;
+    }
+  }
+  if (isReadableStreamLike(source)) {
+    yield* readReadableStream(source);
+    return;
+  }
+  if (isAsyncIterable(source)) {
+    for await (const chunk of source as AsyncIterable<unknown>) {
+      yield ensureUint8Array(chunk);
+    }
+    return;
+  }
+  if (isIterable(source)) {
+    for (const chunk of source as Iterable<unknown>) {
+      yield ensureUint8Array(chunk);
+    }
+    return;
+  }
+  throw new Error('Unsupported content source; expected binary data');
 }
 
 export function base64Encode(bytes: Uint8Array): string {
-	if (BufferCtor) {
-		return BufferCtor.from(bytes).toString('base64');
-	}
-	let binary = '';
-	for (let i = 0; i < bytes.byteLength; i++) {
-		binary += String.fromCharCode(bytes[i]);
-	}
-	const btoaFn = (globalThis as { btoa?: (data: string) => string }).btoa;
-	if (typeof btoaFn === 'function') {
-		return btoaFn(binary);
-	}
-	throw new Error('Base64 encoding is not supported in this environment');
+  if (BufferCtor) {
+    return BufferCtor.from(bytes).toString('base64');
+  }
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const btoaFn = (globalThis as { btoa?: (data: string) => string }).btoa;
+  if (typeof btoaFn === 'function') {
+    return btoaFn(binary);
+  }
+  throw new Error('Base64 encoding is not supported in this environment');
 }
 
 export function requiresDuplex(body: unknown): boolean {
-	if (!body || typeof body !== 'object') {
-		return false;
-	}
-
-	if (typeof (body as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function') {
-		return true;
-	}
-
-	const readableStreamCtor = (
-		globalThis as {
-			ReadableStream?: new (...args: unknown[]) => unknown;
-		}
-	).ReadableStream;
-	if (readableStreamCtor && body instanceof readableStreamCtor) {
-		return true;
-	}
-
-	return false;
+  if (!body || typeof body !== 'object') {
+    return false;
+  }
+
+  if (
+    typeof (body as { [Symbol.asyncIterator]?: unknown })[
+      Symbol.asyncIterator
+    ] === 'function'
+  ) {
+    return true;
+  }
+
+  const readableStreamCtor = (
+    globalThis as {
+      ReadableStream?: new (...args: unknown[]) => unknown;
+    }
+  ).ReadableStream;
+  if (readableStreamCtor && body instanceof readableStreamCtor) {
+    return true;
+  }
+
+  return false;
 }
 
 export function toRequestBody(iterable: AsyncIterable<Uint8Array>): unknown {
-	const readableStreamCtor = (
-		globalThis as { ReadableStream?: new (underlyingSource: unknown) => unknown }
-	).ReadableStream;
-	if (typeof readableStreamCtor === 'function') {
-		const iterator = iterable[Symbol.asyncIterator]();
-		return new readableStreamCtor({
-			async pull(controller: { enqueue(chunk: Uint8Array): void; close(): void }) {
-				const { value, done } = await iterator.next();
-				if (done) {
-					controller.close();
-					return;
-				}
-				controller.enqueue(value!);
-			},
-			async cancel(reason: unknown) {
-				if (typeof iterator.return === 'function') {
-					await iterator.return(reason);
-				}
-			},
-		});
-	}
-	return iterable;
+  const readableStreamCtor = (
+    globalThis as {
+      ReadableStream?: new (underlyingSource: unknown) => unknown;
+    }
+  ).ReadableStream;
+  if (typeof readableStreamCtor === 'function') {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new readableStreamCtor({
+      async pull(controller: {
+        enqueue(chunk: Uint8Array): void;
+        close(): void;
+      }) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value!);
+      },
+      async cancel(reason: unknown) {
+        if (typeof iterator.return === 'function') {
+          await iterator.return(reason);
+        }
+      },
+    });
+  }
+  return iterable;
 }
 
-async function* readReadableStream(stream: ReadableStreamLike<unknown>): AsyncIterable<Uint8Array> {
-	const reader = stream.getReader();
-	try {
-		while (true) {
-			const { value, done } = await reader.read();
-			if (done) {
-				break;
-			}
-			if (value !== undefined) {
-				yield ensureUint8Array(value);
-			}
-		}
-	} finally {
-		reader.releaseLock?.();
-	}
+async function* readReadableStream(
+  stream: ReadableStreamLike<unknown>
+): AsyncIterable<Uint8Array> {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value !== undefined) {
+        yield ensureUint8Array(value);
+      }
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
 }
 
 function ensureUint8Array(value: unknown): Uint8Array {
-	if (value instanceof Uint8Array) {
-		return value;
-	}
-	if (value instanceof ArrayBuffer) {
-		return new Uint8Array(value);
-	}
-	if (ArrayBuffer.isView(value)) {
-		return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-	}
-	if (typeof value === 'string') {
-		return new TextEncoder().encode(value);
-	}
-	if (BufferCtor && BufferCtor.isBuffer(value)) {
-		return value as Uint8Array;
-	}
-	throw new Error('Unsupported chunk type; expected binary data');
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === 'string') {
+    return new TextEncoder().encode(value);
+  }
+  if (BufferCtor && BufferCtor.isBuffer(value)) {
+    return value as Uint8Array;
+  }
+  throw new Error('Unsupported chunk type; expected binary data');
 }
 
 function isBlobLike(value: unknown): value is BlobLike {
-	return (
-		typeof value === 'object' && value !== null && typeof (value as BlobLike).stream === 'function'
-	);
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as BlobLike).stream === 'function'
+  );
 }
 
-function isReadableStreamLike<T>(value: unknown): value is ReadableStreamLike<T> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		typeof (value as ReadableStreamLike<T>).getReader === 'function'
-	);
+function isReadableStreamLike<T>(
+  value: unknown
+): value is ReadableStreamLike<T> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as ReadableStreamLike<T>).getReader === 'function'
+  );
 }
 
 function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		Symbol.asyncIterator in (value as Record<string, unknown>)
-	);
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Symbol.asyncIterator in (value as Record<string, unknown>)
+  );
 }
 
 function isIterable(value: unknown): value is Iterable<unknown> {
-	return (
-		typeof value === 'object' &&
-		value !== null &&
-		Symbol.iterator in (value as Record<string, unknown>)
-	);
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Symbol.iterator in (value as Record<string, unknown>)
+  );
 }
 
 function concatChunks(a: Uint8Array, b: Uint8Array): Uint8Array {
-	if (a.byteLength === 0) {
-		return b;
-	}
-	if (b.byteLength === 0) {
-		return a;
-	}
-	const merged = new Uint8Array(a.byteLength + b.byteLength);
-	merged.set(a, 0);
-	merged.set(b, a.byteLength);
-	return merged;
+  if (a.byteLength === 0) {
+    return b;
+  }
+  if (b.byteLength === 0) {
+    return a;
+  }
+  const merged = new Uint8Array(a.byteLength + b.byteLength);
+  merged.set(a, 0);
+  merged.set(b, a.byteLength);
+  return merged;
 }