Add support for reading from a WebStreams

.github/workflows/main.yml

@@ -10,6 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
+          - 22
           - 20
           - 18
     steps:

core.d.ts

@@ -1,4 +1,9 @@
-import type {Readable as ReadableStream} from 'node:stream';
+/**
+ * Typings for primary entry point, Node.js specific typings can be found in index.d.ts
+ */
+
+import type {ReadableStream as WebReadableStream} from 'node:stream/web';
+import type {Readable as NodeReadableStream} from 'node:stream';
 import type {ITokenizer} from 'strtok3';
 
 export type FileExtension =
@@ -318,7 +323,7 @@ export type FileTypeResult = {
 	readonly mime: MimeType;
 };
 
-export type ReadableStreamWithFileType = ReadableStream & {
+export type ReadableStreamWithFileType = WebReadableStream & {
 	readonly fileType?: FileTypeResult;
 };
 
@@ -339,10 +344,10 @@ Detect the file type of a Node.js [readable stream](https://nodejs.org/api/strea
 
 The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
 
-@param stream - A readable stream representing file data.
+@param stream - A Node.js Readable stream or Web API Readable Stream representing file data. The Web Readable stream **must be a byte stream**.
 @returns The detected file type, or `undefined` when there is no match.
 */
-export function fileTypeFromStream(stream: ReadableStream): Promise<FileTypeResult | undefined>;
+export function fileTypeFromStream(stream: WebReadableStream): Promise<FileTypeResult | undefined>;
 
 /**
 Detect the file type from an [`ITokenizer`](https://github.com/Borewit/strtok3#tokenizer) source.
@@ -420,7 +425,7 @@ if (stream2.fileType?.mime === 'image/jpeg') {
 }
 ```
 */
-export function fileTypeStream(readableStream: ReadableStream, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
+export function fileTypeStream(readableStream: WebReadableStream<Uint8Array>, options?: StreamOptions): Promise<ReadableStreamWithFileType>;
 
 /**
 Detect the file type of a [`Blob`](https://nodejs.org/api/buffer.html#class-blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
@@ -511,7 +516,7 @@ export declare class FileTypeParser {
 	/**
 	Works the same way as {@link fileTypeFromStream}, additionally taking into account custom detectors (if any were provided to the constructor).
 	*/
-	fromStream(stream: ReadableStream): Promise<FileTypeResult | undefined>;
+	fromStream(stream: NodeReadableStream): Promise<FileTypeResult | undefined>;
 
 	/**
 	Works the same way as {@link fileTypeFromTokenizer}, additionally taking into account custom detectors (if any were provided to the constructor).
@@ -526,5 +531,5 @@ export declare class FileTypeParser {
 	/**
 	Works the same way as {@link fileTypeStream}, additionally taking into account custom detectors (if any were provided to the constructor).
 	*/
-	toDetectionStream(readableStream: ReadableStream, options?: StreamOptions): Promise<FileTypeResult | undefined>;
+	toDetectionStream(readableStream: NodeReadableStream, options?: StreamOptions): Promise<FileTypeResult | undefined>;
 }

core.js

@@ -1,3 +1,7 @@
+/**
+ * Primary entry point, Node.js specific entry point is index.js
+ */
+
 import * as Token from 'token-types';
 import * as strtok3 from 'strtok3/core';
 import {includes, indexOf, getUintBE} from 'uint8array-extras';
@@ -88,12 +92,11 @@ export class FileTypeParser {
 	}
 
 	async fromBlob(blob) {
-		const buffer = await blob.arrayBuffer();
-		return this.fromBuffer(new Uint8Array(buffer));
+		return this.fromStream(blob.stream());
 	}
 
 	async fromStream(stream) {
-		const tokenizer = await strtok3.fromStream(stream);
+		const tokenizer = await strtok3.fromWebStream(stream);
 		try {
 			return await this.fromTokenizer(tokenizer);
 		} finally {

index.d.ts

@@ -1,13 +1,30 @@
-import type {FileTypeResult} from './core.js';
-
 /**
-Detect the file type of a file path.
+ * Typings for Node.js specific entry point
+ */
+
+import type {Readable as NodeReadableStream} from 'node:stream';
+import type {ReadableStream as WebReadableStream} from 'node:stream/web';
+import type {FileTypeResult} from './core.js';
+import {FileTypeParser} from './core.js';
 
-The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
+export declare class NodeFileTypeParser extends FileTypeParser {
+	/**
+	 *
+	 * @param stream Node.js Stream readable or Web API StreamReadable
+	 */
+	fromStream(stream: WebReadableStream<Uint8Array> | NodeReadableStream): Promise<FileTypeResult | undefined>;
+}
 
-@param path - The file path to parse.
-@returns The detected file type and MIME type or `undefined` when there is no match.
-*/
+/**
+ * Detect the file type of a file path.
+ *
+ * The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
+ *
+ * @param path
+ * @returns The detected file type and MIME type or `undefined` when there is no match.
+ */
 export function fileTypeFromFile(path: string): Promise<FileTypeResult | undefined>;
 
+export function fileTypeFromStream(stream: WebReadableStream<Uint8Array> | NodeReadableStream): Promise<FileTypeResult | undefined>;
+
 export * from './core.js';

index.js

@@ -1,6 +1,22 @@
+/**
+ * Node.js specific entry point
+ */
+
+import {ReadableStream as WebReadableStream} from 'node:stream/web';
 import * as strtok3 from 'strtok3';
 import {FileTypeParser} from './core.js';
 
+export class NodeFileTypeParser extends FileTypeParser {
+	async fromStream(stream) {
+		const tokenizer = await (stream instanceof WebReadableStream ? strtok3.fromWebStream(stream) : strtok3.fromStream(stream));
+		try {
+			return super.fromTokenizer(tokenizer);
+		} finally {
+			await tokenizer.close();
+		}
+	}
+}
+
 export async function fileTypeFromFile(path, fileTypeOptions) {
 	const tokenizer = await strtok3.fromFile(path);
 	try {
@@ -11,4 +27,8 @@ export async function fileTypeFromFile(path, fileTypeOptions) {
 	}
 }
 
-export * from './core.js';
+export async function fileTypeFromStream(stream, fileTypeOptions) {
+	return (new NodeFileTypeParser(fileTypeOptions)).fromStream(stream);
+}
+
+export {fileTypeFromBuffer, fileTypeFromBlob, fileTypeStream, FileTypeParser, supportedMimeTypes, supportedExtensions} from './core.js';

index.test-d.ts

@@ -1,8 +1,9 @@
 import {createReadStream} from 'node:fs';
+import {ReadableStream as WebReadableStream} from 'node:stream/web';
 import {expectType} from 'tsd';
 import {
 	type FileTypeResult as FileTypeResultBrowser,
-} from './browser.js';
+} from './core.js';
 import {
 	fileTypeFromBlob,
 	fileTypeFromBuffer,
@@ -54,13 +55,13 @@ expectType<ReadonlySet<FileExtension>>(supportedExtensions);
 
 expectType<ReadonlySet<MimeType>>(supportedMimeTypes);
 
-const readableStream = createReadStream('file.png');
-const streamWithFileType = fileTypeStream(readableStream);
+const webStream = new WebReadableStream<Uint8Array>();
+const streamWithFileType = fileTypeStream(webStream);
 expectType<Promise<ReadableStreamWithFileType>>(streamWithFileType);
 (async () => {
 	const {fileType} = await streamWithFileType;
 	expectType<FileTypeResult | undefined>(fileType);
 })();
 
 // Browser
-expectType<Promise<FileTypeResultBrowser | undefined>>(fileTypeFromBlob(new Blob()));
+expectType<Promise<FileTypeResultBrowser | undefined>>(fileTypeFromBlob(new Blob([])));

package.json

@@ -14,7 +14,7 @@
 	"exports": {
 		".": {
 			"node": "./index.js",
-			"default": "./browser.js"
+			"default": "./core.js"
 		},
 		"./core": "./core.js"
 	},
@@ -28,8 +28,6 @@
 	"files": [
 		"index.js",
 		"index.d.ts",
-		"browser.js",
-		"browser.d.ts",
 		"core.js",
 		"core.d.ts",
 		"supported.js",
@@ -210,7 +208,6 @@
 		"fbx"
 	],
 	"dependencies": {
-		"readable-web-to-node-stream": "^3.0.2",
 		"strtok3": "^7.1.0",
 		"token-types": "^6.0.0",
 		"uint8array-extras": "^1.3.0"

readme.md

@@ -147,7 +147,7 @@ The file path to parse.
 
 ### fileTypeFromStream(stream)
 
-Detect the file type of a Node.js [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+Detect the file type of a [Node.js readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) or a [Web API ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream).
 
 The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
 
@@ -168,6 +168,8 @@ A readable stream representing file data.
 
 Detect the file type of a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
 
+It will **stream** the underlying Blob, and required a [ReadableStreamBYOBReader](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader) which **require Node.js ≥ 20**.
+
 The file type is detected by checking the [magic number](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_numbers_in_files) of the buffer.
 
 Returns a `Promise` for an object with the detected file type: