insite-ws-transfers 1.0.465

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Eugene Nesvetaev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# inSite file transfers over WebSockets
+
+## Installation
+
+```sh
+$ npm install insite-ws-transfers
+```
+
+Or
+
+```sh
+$ yarn add insite-ws-transfers
+```

package/lib/IncomingTransfer.js

@@ -0,0 +1,272 @@
+import { callArgsSymbol, headers, progressInterval } from "./common";
+
+
+export class IncomingTransfer {
+	constructor(ws, kind, id, { type, collect, encoding, size, metadata }) {
+		this.ws = ws;
+		this[callArgsSymbol] = ws.wss ? [ ws.wss, ws ] : [ ws ];
+		this.incomingTransport = (ws.wss ?? ws).incomingTransport;
+		
+		this.kind = kind;
+		this.id = id;
+		this.type = type;
+		this.collect = !!collect;
+		this.encoding = encoding;
+		this.size = size;
+		this.metadata = metadata;
+		
+		this.listeners = this.incomingTransport.listeners.get(this.kind);
+		
+		this.incomingTransport.transfers.set(this.id, this);
+		
+		return (async () => {
+			await this.#setup();
+			
+			this.confirm();
+			
+			return this;
+		})();
+	}
+	
+	#methods;
+	isAborted = false;
+	isAbortedBySender = false;
+	isAbortedByReceiver = false;
+	isTransfered = false;
+	confirmResponse;
+	beginAt = null;
+	#prevChunkAt = null;
+	#chunksQueue = [];
+	#isProcessing = false;
+	duration = null;
+	transferedSize = 0;
+	processedSize = 0;
+	bytesPerMs = null;
+	progress = 0;
+	endAt = null;
+	error = null;
+	
+	
+	#progressInterval;
+	#lastProgress = 0;
+	
+	async #setup() {
+		
+		this.#methods = this.constructor.methods[this.type];
+		
+		if (this.#methods)
+			await this.#methods.setup.call(this);
+		else
+			throw new Error(`Unknown type of transfer "${this.type}"`);
+		
+	}
+	
+	async confirm() {
+		
+		for (const { begin } of this.listeners)
+			if (await begin?.call(...this[callArgsSymbol], this) === false)
+				return this.throw("Transfer was rejected by receiver");
+		
+		this.beginAt =
+			this.#prevChunkAt =
+				Date.now();
+		
+		this.ws.sendMessage(headers.confirm, this.id, this.confirmResponse);
+		
+		this.#progressInterval = setInterval(() => {
+			
+			if (this.#lastProgress !== this.progress) {
+				this.#lastProgress = this.progress;
+				this.ws.sendMessage(headers.progress, this.id, this.progress);
+			}
+			
+		}, progressInterval);
+		
+	}
+	
+	handleChunk(chunk, length = chunk.length) {
+		
+		const ts = Date.now();
+		this.bytesPerMs = length / (ts - this.#prevChunkAt);
+		this.#prevChunkAt = ts;
+		this.transferedSize += length;
+		
+		this.#chunksQueue.push([ chunk, length ]);
+		
+		if (!this.#isProcessing) {
+			this.#isProcessing = true;
+			this.#process();
+		}
+		
+	}
+	
+	async #process() {
+		
+		let [ chunk, length ] = this.#chunksQueue.shift();
+		
+		if (this.#methods.transformChunk)
+			chunk = await this.#methods.transformChunk.call(this, chunk);
+		
+		if (this.collect)
+			await this.#methods.collect.call(this, chunk);
+		
+		for (const { chunk: chunkListener, progress: progressListener } of this.listeners)
+			await (chunkListener ?? progressListener)?.call(...this[callArgsSymbol], this, chunk);
+		
+		this.processedSize += length;
+		if (this.size)
+			this.progress = this.processedSize / this.size;
+		
+		if (this.#chunksQueue.length)
+			this.#process();
+		else {
+			this.#isProcessing = false;
+			
+			if (this.isTransfered)
+				this.#complete();
+		}
+		
+	}
+	
+	handleSent() {
+		
+		this.isTransfered = true;
+		
+		if (!this.size)
+			this.size = this.transferedSize;
+		
+		this.endAt = Date.now();
+		this.duration = this.endAt - this.beginAt;
+		this.bytesPerMs = this.size / this.duration;
+		
+		if (!this.#isProcessing)
+			this.#complete();
+		
+	}
+	
+	async #complete() {
+		
+		this.progress = 1;
+		
+		await this.#methods.done?.call(this);
+		
+		for (const { end } of this.listeners)
+			await end?.call(...this[callArgsSymbol], this);
+		
+		clearInterval(this.#progressInterval);
+		
+		this.incomingTransport.transfers.delete(this.id);
+		
+		this.ws.sendMessage(headers.completed, this.id);
+		
+	}
+	
+	abort(bySender = false) {
+		
+		this.isAborted = true;
+		this.isAbortedBySender = bySender;
+		this.isAbortedByReceiver = !bySender;
+		
+		return this.throw(`Transfer is aborted by ${bySender ? "sender" : "receiver"}`, !bySender);
+	}
+	
+	throw(errorMessage, sendToSender = true) {
+		
+		this.incomingTransport.transfers.delete(this.id);
+		
+		clearInterval(this.#progressInterval);
+		
+		this.error = new Error(errorMessage);
+		
+		for (const { error } of this.listeners)
+			error?.call(...this[callArgsSymbol], this, this.error);
+		
+		if (sendToSender)
+			this.ws.sendMessage(headers.error, this.id, errorMessage);
+		
+	}
+	
+	serialize() {
+		return {
+			id: this.id,
+			kind: this.kind,
+			type: this.type,
+			collect: this.collect,
+			encoding: this.encoding,
+			size: this.size,
+			metadata: this.metadata,
+			isAborted: this.isAborted,
+			isAbortedBySender: this.isAbortedBySender,
+			isAbortedByReceiver: this.isAbortedByReceiver,
+			isTransfered: this.isTransfered,
+			confirmResponse: this.confirmResponse,
+			beginAt: this.beginAt,
+			duration: this.duration,
+			transferedSize: this.transferedSize,
+			processedSize: this.processedSize,
+			bytesPerMs: this.bytesPerMs,
+			progress: this.progress,
+			endAt: this.endAt,
+			error: this.error
+		};
+	}
+	
+	
+	static methods = {
+		
+		object: {
+			setup() {
+				
+				this.data = "";
+				
+			},
+			
+			collect(chunk) {
+				this.data += chunk;
+				
+			},
+			
+			done() {
+				this.data = JSON.parse(this.data);
+				
+			}
+		},
+		
+		datauri: {
+			setup() {
+				
+				if (this.collect)
+					this.data = "";
+				
+			},
+			
+			collect(chunk) {
+				this.data += chunk;
+				
+			},
+			
+			done() {
+				
+				if (this.collect)
+					this.data = `data:${this.metadata.type};base64,${this.data}`;
+				
+			}
+		},
+		
+		string: {
+			setup() {
+				
+				if (this.collect)
+					this.data = "";
+				
+			},
+			
+			collect(chunk) {
+				this.data += chunk;
+				
+			}
+		}
+		
+	};
+	
+}

package/lib/IncomingTransport.js

@@ -0,0 +1,92 @@
+import { headers, sizeLimit as defaultSizeLimit } from "./common";
+import { IncomingTransfer } from "./IncomingTransfer";
+
+
+export class IncomingTransport {
+	constructor(ws, options = {}) {
+		ws.incomingTransport = this;
+		
+		const {
+			sizeLimit = defaultSizeLimit
+		} = options;
+		
+		this.sizeLimit = sizeLimit;
+		
+		ws.listenerHandlers.add(this.listenerHandler);
+		
+		if (ws.isWebSocketServer) {
+			this.listenerHandlerRegExp = /^client-transfer:(.*)$/;
+			
+			ws.on(`client-message:${headers.request}`, (...args) => IncomingTransport.handleRequest.call(...args));
+			ws.on(`client-message:${headers.chunk}`, (...args) => IncomingTransport.handleChunk.call(...args));
+			ws.on(`client-message:${headers.sent}`, (...args) => IncomingTransport.handleSent.call(...args));
+			ws.on(`client-message:${headers.abort}`, (...args) => IncomingTransport.handleAbort.call(...args));
+		} else {
+			this.listenerHandlerRegExp = /^transfer:(.*)$/;
+			
+			ws.on(`message:${headers.request}`, IncomingTransport.handleRequest);
+			ws.on(`message:${headers.chunk}`, IncomingTransport.handleChunk);
+			ws.on(`message:${headers.sent}`, IncomingTransport.handleSent);
+			ws.on(`message:${headers.abort}`, IncomingTransport.handleAbort);
+		}
+		
+	}
+	
+	listeners = new Map();
+	
+	listenerHandler = (add, eventName, listener) => {
+		const kind = eventName.match(this.listenerHandlerRegExp)?.[1];
+		if (kind) {
+			if (add)
+				this.listeners.get(kind)?.add(listener) ??
+					this.listeners.set(kind, new Set([ listener ]));
+			else
+				if (listener)
+					this.listeners.get(kind)?.delete(listener);
+				else
+					this.listeners.delete(kind);
+			
+			return true;
+		}
+		
+	};
+	
+	transfers = new Map();
+	
+	
+	static IncomingTransfer = IncomingTransfer;
+	
+	static handleRequest(kind, id, { type, size, metadata, ...restProps }) {
+		
+		const { incomingTransport } = this.wss ?? this;
+		const { IncomingTransportTransfer } = incomingTransport.constructor;
+		
+		if (!incomingTransport.listeners.has(kind))
+			this.sendMessage(headers.error, id, `Unknown kind of file "${kind}"`);
+		else if (incomingTransport.transfers.has(id))
+			this.sendMessage(headers.error, id, "Transfer already exists");
+		else if (!IncomingTransportTransfer.methods[type])
+			this.sendMessage(headers.error, id, "Unknown type of transfer");
+		else if (size > this.sizeLimit)
+			this.sendMessage(headers.error, id, `Transfer size (${size} bytes) exeeds limit of ${this.sizeLimit} bytes`);
+		else
+			new IncomingTransportTransfer(this, kind, id, { type, size, metadata, ...restProps });
+		
+	}
+	
+	static handleChunk(id, ...restArgs) {
+		(this.wss ?? this).incomingTransport.transfers.get(id)?.handleChunk(...restArgs);
+		
+	}
+	
+	static handleSent(id) {
+		(this.wss ?? this).incomingTransport.transfers.get(id)?.handleSent();
+		
+	}
+	
+	static handleAbort(id) {
+		(this.wss ?? this).incomingTransport.transfers.get(id)?.abort(true);
+		
+	}
+	
+}

package/lib/OutgoingTransfer.js

@@ -0,0 +1,296 @@
+import { uid } from "@nesvet/n";
+import { callArgsSymbol, chunkSize, headers } from "./common";
+import { StringStreamer } from "./StringStreamer";
+
+
+// FIXME
+
+
+export class OutgoingTransfer {
+	constructor(ws, kind, {
+		data,
+		type,
+		incomingType,
+		collect,
+		metadata,
+		size,
+		chunkSize,
+		encoding,
+		incomingEncoding,
+		onBegin,
+		onSenderProgress,
+		onProgress,
+		onEnd,
+		onError
+	}) {
+		
+		this.ws = ws;
+		this[callArgsSymbol] = ws.wss ? [ ws.wss, ws ] : [ ws ];
+		this.outgoingTransport = (ws.wss ?? ws).outgoingTransport;
+		
+		this.kind = kind;
+		
+		this.data = data;
+		this.collect = collect ?? false;
+		this.metadata = metadata;
+		this.size = size ?? null;
+		this.encoding = encoding;
+		this.chunkSize = chunkSize ?? this.constructor.chunkSize;
+		
+		if (onBegin)
+			this.onBegin = onBegin;
+		if (onSenderProgress)
+			this.onSenderProgress = onSenderProgress;
+		if (onProgress)
+			this.onProgress = onProgress;
+		if (onEnd)
+			this.onEnd = onEnd;
+		if (onError)
+			this.onError = onError;
+		
+		this.outgoingTransport.transfers.set(this.id, this);
+		
+		return (async () => {
+			
+			await this.#setup(type);
+			
+			this.ws.sendMessage(headers.request, this.kind, this.id, {
+				type: incomingType ?? this.type,
+				collect: this.collect,
+				encoding: incomingEncoding ?? this.encoding,
+				size: this.size,
+				metadata: this.metadata
+			});
+			
+			return this;
+		})();
+	}
+	
+	id = uid();
+	#methods = null;
+	isAborted = false;
+	isTransfered = false;
+	confirmResponse;
+	beginAt = null;
+	#prevChunkAt = null;
+	#chunksQueue = [];
+	#isProcessing = false;
+	duration = null;
+	transferedSize = 0;
+	bytesPerMs = null;
+	senderProgress = 0;
+	progress = 0;
+	endAt = null;
+	error = null;
+	
+	async #setup(type) {
+		
+		for (const [ availableType, test, methods ] of this.constructor.methods)
+			if (type === availableType || test(this.data)) {
+				this.type = availableType;
+				this.#methods = methods;
+				break;
+			}
+		
+		if (this.type) {
+			await this.#methods.setup.call(this);
+			delete this.data;
+		} else
+			throw new Error("Unknown type of transfer");
+		
+	}
+	
+	async handleConfirm(confirmResponse) {
+		this.confirmResponse = confirmResponse;
+		
+		this.beginAt =
+			this.#prevChunkAt =
+				Date.now();
+		
+		await this.onBegin?.call(...this[callArgsSymbol], this);
+		
+		this.#methods.confirm.call(this);
+		
+	}
+	
+	handleChunk = chunk => {
+		this.#chunksQueue.push(chunk);
+		
+		if (!this.#isProcessing) {
+			this.#isProcessing = true;
+			this.#process();
+		}
+		
+	};
+	
+	async #process() {
+		
+		let chunk = this.#chunksQueue.shift();
+		
+		const chunkLength = chunk.length;
+		
+		if (this.#methods.transformChunk)
+			chunk = await this.#methods.transformChunk.call(this, chunk);
+		
+		this.ws.sendMessage(headers.chunk, this.id, chunk, chunkLength);
+		
+		const ts = Date.now();
+		this.bytesPerMs = chunkLength / (ts - this.#prevChunkAt);
+		this.#prevChunkAt = ts;
+		this.transferedSize += chunkLength;
+		
+		if (this.size)
+			this.senderProgress = this.transferedSize / this.size;
+		
+		await this.onSenderProgress?.call(...this[callArgsSymbol], this);
+		
+		if (this.#chunksQueue.length)
+			this.#process();
+		else {
+			this.#isProcessing = false;
+			
+			if (this.senderProgress === 1)
+				this.sent();
+		}
+		
+	}
+	
+	sent = () => this.ws.sendMessage(headers.sent, this.id);
+	
+	handleProgress(progress) {
+		this.progress = progress;
+		
+		this.onProgress?.call(...this[callArgsSymbol], this);
+		
+	}
+	
+	async handleCompleted() {
+		
+		this.isTransfered = true;
+		
+		if (!this.size) {
+			this.size = this.transferedSize;
+			this.senderProgress = 1;
+		}
+		
+		this.endAt = Date.now();
+		this.duration = this.endAt - this.beginAt;
+		this.bytesPerMs = this.size / this.duration;
+		
+		this.outgoingTransport.transfers.delete(this.id);
+		
+		if (this.progress !== 1) {
+			this.progress = 1;
+			await this.onProgress?.call(...this[callArgsSymbol], this);
+		}
+		
+		this.onEnd?.call(...this[callArgsSymbol], this);
+		
+	}
+	
+	throw(errorMessage) {
+		
+		this.outgoingTransport.transfers.delete(this.id);
+		
+		this.error = new Error(errorMessage);
+		
+		this.onError?.call(...this[callArgsSymbol], this, this.error);
+		
+	}
+	
+	abort() {
+		
+		this.isAborted = true;
+		
+		this.ws.sendMessage(headers.abort, this.id);
+		
+		return this.throw("Transfer is aborted by sender");
+	}
+	
+	serialize() {
+		return {
+			id: this.id,
+			kind: this.kind,
+			type: this.type,
+			collect: this.collect,
+			encoding: this.encoding,
+			size: this.size,
+			metadata: this.metadata,
+			isAborted: this.isAborted,
+			isTransfered: this.isTransfered,
+			confirmResponse: this.confirmResponse,
+			beginAt: this.beginAt,
+			duration: this.duration,
+			transferedSize: this.transferedSize,
+			bytesPerMs: this.bytesPerMs,
+			senderProgress: this.senderProgress,
+			progress: this.progress,
+			endAt: this.endAt,
+			error: this.error
+		};
+	}
+	
+	
+	static methods = [
+		
+		[ "object", data => typeof data == "object", {
+			
+			setup() {
+				
+				this.stringStreamer = new StringStreamer(JSON.stringify(this.data), { chunkSize: this.chunkSize });
+				this.collect = true;
+				this.size = this.stringStreamer.size;
+				this.encoding = "utf8";
+				
+			},
+			
+			confirm() {
+				
+				this.stringStreamer.start(this.handleChunk);
+				
+			}
+		} ],
+		
+		[ "datauri", data => typeof data == "string" && /^data:[\w-.]+\/[\w-.+,]+(?:;base64)?,/.test(data), {
+			
+			setup() {
+				
+				const [ type, data ] = this.data.split(/^data:|;base64,|,/).slice(1);
+				
+				this.stringStreamer = new StringStreamer(data, { chunkSize: this.chunkSize });
+				this.size = this.stringStreamer.size;
+				this.encoding = "base64";
+				this.metadata = { ...this.metadata, type };
+				
+			},
+			
+			confirm() {
+				
+				this.stringStreamer.start(this.handleChunk);
+				
+			}
+		} ],
+		
+		[ "string", data => typeof data == "string", {
+			
+			setup() {
+				
+				this.stringStreamer = new StringStreamer(this.data, { chunkSize: this.chunkSize });
+				this.size = this.stringStreamer.size;
+				if (!this.encoding)
+					this.encoding = "utf8";
+				
+			},
+			
+			confirm() {
+				
+				this.stringStreamer.start(this.handleChunk);
+				
+			}
+		} ]
+		
+	];
+	
+	static chunkSize = chunkSize;
+	
+}

package/lib/OutgoingTransport.js

@@ -0,0 +1,59 @@
+import { headers } from "./common";
+import { OutgoingTransfer } from "./OutgoingTransfer";
+
+
+export class OutgoingTransport {
+	constructor(ws) {
+		ws.outgoingTransport = this;
+		
+		if (ws.isWebSocketServer) {
+			ws.options.WebSocket.prototype.transfer = OutgoingTransport.transfer;
+			
+			ws.on(`client-message:${headers.confirm}`, (...args) => OutgoingTransport.handleConfirm.call(...args));
+			ws.on(`client-message:${headers.progress}`, (...args) => OutgoingTransport.handleProgress.call(...args));
+			ws.on(`client-message:${headers.completed}`, (...args) => OutgoingTransport.handleCompleted.call(...args));
+			ws.on(`client-message:${headers.error}`, (...args) => OutgoingTransport.handleError.call(...args));
+		} else {
+			ws.transfer = OutgoingTransport.transfer;
+			
+			ws.on(`message:${headers.confirm}`, OutgoingTransport.handleConfirm);
+			ws.on(`message:${headers.progress}`, OutgoingTransport.handleProgress);
+			ws.on(`message:${headers.completed}`, OutgoingTransport.handleCompleted);
+			ws.on(`message:${headers.error}`, OutgoingTransport.handleError);
+		}
+		
+	}
+	
+	transfers = new Map();
+	
+	
+	static OutgoingTransfer = OutgoingTransfer;
+	
+	static async transfer(...args) {
+		
+		const { OutgoingTransportTransfer } = (this.wss ?? this).outgoingTransport.constructor;
+		
+		return new OutgoingTransportTransfer(this, ...args);
+	}
+	
+	static handleConfirm(id, ...restArgs) {
+		(this.wss ?? this).outgoingTransport.transfers.get(id)?.handleConfirm(...restArgs);
+		
+	}
+	
+	static handleProgress(id, ...restArgs) {
+		(this.wss ?? this).outgoingTransport.transfers.get(id)?.handleProgress(...restArgs);
+		
+	}
+	
+	static handleCompleted(id, ...restArgs) {
+		(this.wss ?? this).outgoingTransport.transfers.get(id)?.handleCompleted(...restArgs);
+		
+	}
+	
+	static handleError(id, errorMessage) {
+		(this.wss ?? this).outgoingTransport.transfers.get(id)?.throw(errorMessage);
+		
+	}
+	
+}

package/lib/StringStreamer.js

@@ -0,0 +1,52 @@
+export class StringStreamer {
+	constructor(string, options = {}) {
+		this.string = string;
+		this.size = this.string.length;
+		
+		const {
+			chunkSize = 1024 * 256
+		} = options;
+		
+		this.chunkSize = chunkSize;
+		
+	}
+	
+	#start = 0;
+	#end = 0;
+	
+	isAborted = false;
+	
+	start(listener) {
+		this.listener = listener;
+		
+		this.#next();
+		
+	}
+	
+	async #next() {
+		
+		if (!this.isAborted) {
+			this.#end = Math.min(this.#start + this.chunkSize, this.size);
+			
+			const chunk = await new Promise(resolve => resolve(this.string.slice(this.#start, this.#end)));
+			
+			if (!this.isAborted) {
+				await this.listener(chunk);
+				
+				if (this.#end < this.size) {
+					this.#start = this.#end;
+					
+					this.#next();
+				}
+			}
+		}
+		
+	}
+	
+	abort() {
+		
+		this.isAborted = true;
+		
+	}
+	
+}

package/lib/browser/FileStreamer.js

@@ -0,0 +1,63 @@
+export class FileStreamer {
+	constructor(file, options = {}) {
+		this.file = file;
+		this.size = this.file.size;
+		
+		const {
+			chunkSize = 1024 * 256
+		} = options;
+		
+		this.chunkSize = chunkSize;
+		
+		this.fileReader = new FileReader();
+		
+		this.fileReader.onload = this.#handleFileReaderLoad;
+		
+	}
+	
+	#start = 0;
+	#end = 0;
+	
+	isAborted = false;
+	
+	start(listener) {
+		this.listener = listener;
+		
+		this.#next();
+		
+	}
+	
+	#next() {
+		
+		if (!this.isAborted) {
+			this.#end = Math.min(this.#start + this.chunkSize, this.size);
+			
+			this.fileReader.readAsArrayBuffer(this.file.slice(this.#start, this.#end));
+		}
+		
+	}
+	
+	#handleFileReaderLoad = async () => {
+		
+		if (!this.isAborted) {
+			const arrayBuffer = this.fileReader.result;
+			arrayBuffer.length = arrayBuffer.byteLength;
+			
+			await this.listener(arrayBuffer);
+			
+			if (this.#end < this.size) {
+				this.#start = this.#end;
+				
+				this.#next();
+			}
+		}
+		
+	};
+	
+	abort() {
+		
+		this.isAborted = true;
+		
+	}
+	
+}

package/lib/browser/arrayBufferToBase64.js

@@ -0,0 +1,11 @@
+export async function arrayBufferToBase64(arrayBuffer) {
+	return new Promise(resolve => {
+		
+		const fileReader = new FileReader();
+		
+		fileReader.onload = ({ target: { result } }) => resolve(result.substring(result.indexOf(",") + 1));
+		
+		fileReader.readAsDataURL(new Blob([ arrayBuffer ]));
+		
+	});
+}

package/lib/browser/incoming.js

@@ -0,0 +1,41 @@
+import { IncomingTransfer } from "../IncomingTransfer";
+import { IncomingTransport } from "../IncomingTransport";
+
+
+class BrowserIncomingTransfer extends IncomingTransfer {
+	
+	static methods = {
+		
+		file: {
+			setup() {
+				
+				if (this.collect)
+					this.data = "";
+				
+			},
+			
+			collect(chunk) {
+				this.data += chunk;
+				
+			},
+			
+			end() {
+				
+				if (this.collect && this.encoding === "utf8")
+					this.data = atob(this.data);
+				
+			}
+		}
+		
+	};
+	
+}
+
+class BrowserIncomingTransport extends IncomingTransport {
+	
+	static IncomingTransfer = BrowserIncomingTransfer;
+	
+}
+
+
+export { BrowserIncomingTransfer as IncomingTransfer, BrowserIncomingTransport as IncomingTransport };

package/lib/browser/index.js

@@ -0,0 +1,2 @@
+export * from "./incoming";
+export * from "./outgoing";

package/lib/browser/outgoing.js

@@ -0,0 +1,61 @@
+import { OutgoingTransfer } from "../OutgoingTransfer";
+import { OutgoingTransport } from "../OutgoingTransport";
+import { arrayBufferToBase64 } from "./arrayBufferToBase64";
+import { FileStreamer } from "./FileStreamer";
+
+
+class BrowserOutgoingTransfer extends OutgoingTransfer {
+	
+	static methods = [
+		
+		[ "file", data => typeof data == "object" && data instanceof File, {
+			
+			setup() {
+				
+				const file = this.data;
+				
+				this.fileStreamer = new FileStreamer(file, { chunkSize: this.chunkSize });
+				
+				const metadata = {
+					name: file.name,
+					type: file.type,
+					size: file.size,
+					modifiedAt: file.lastModified
+				};
+				
+				if (this.metadata)
+					Object.assign(this.metadata, metadata);
+				else
+					this.metadata = metadata;
+				
+				this.size = this.fileStreamer.size;
+				this.encoding = "buffer";
+				
+			},
+			
+			confirm() {
+				
+				this.fileStreamer.start(this.handleChunk);
+				
+			},
+			
+			transformChunk(chunk) {
+				return arrayBufferToBase64(chunk);
+			}
+		} ],
+		
+		...OutgoingTransfer.methods
+		
+	];
+	
+}
+
+class BrowserOutgoingTransport extends OutgoingTransport {
+	
+	static OutgoingTransfer = BrowserOutgoingTransfer;
+	
+}
+
+
+export { BrowserOutgoingTransfer as OutgoingTransfer,
+	BrowserOutgoingTransport as OutgoingTransport };

package/lib/common.js

@@ -0,0 +1,18 @@
+export const headers = {
+	request: "~t-request",
+	confirm: "~t-confirm",
+	chunk: "~t-c",
+	progress: "~t-p",
+	sent: "~t-sent",
+	completed: "~t-completed",
+	abort: "~t-abort",
+	error: "~t-error"
+};
+
+export const sizeLimit = 10 * 1024 * 1024 * 1024;
+
+export const chunkSize = 1024 * 256;
+
+export const callArgsSymbol = Symbol("callArgs");
+
+export const progressInterval = 250;

package/lib/node/incoming.js

@@ -0,0 +1,108 @@
+import { Readable } from "node:stream";
+import { IncomingTransfer } from "../IncomingTransfer";
+import { IncomingTransport } from "../IncomingTransport";
+
+
+class TransferStream extends Readable {
+	constructor(writableStream) {
+		super();
+		
+		this.writable = writableStream;
+		
+		this.promise = new Promise((resolve, reject) => {
+			writableStream.on("close", resolve);
+			writableStream.on("error", reject);
+			
+		});
+		
+		this.pipe(writableStream);
+		
+	}
+	
+	_read() {}
+	
+}
+
+function pipeTo(writableStream) {
+	const stream = new TransferStream(writableStream);
+	
+	this.streams?.push(stream) ??
+		(this.streams = [ stream ]);
+	
+	return writableStream;
+}
+
+const streamMethod = {
+	setup() {
+		
+		if (!this.encoding)
+			this.encoding = "buffer";
+		
+		if (this.encoding === "buffer")
+			this.isBuffer = true;
+		
+		if (this.collect)
+			this.data = this.isBuffer ? Buffer.from("") : "";
+		
+		this.pipeTo = pipeTo;
+		
+	},
+	
+	transformChunk(chunk) {
+		chunk = this.isBuffer ? Buffer.from(chunk, "base64") : Buffer.from(chunk, "base64").toString(this.encoding);
+		
+		if (this.streams)
+			for (const stream of this.streams)
+				stream.push(chunk);
+		
+		return chunk;
+	},
+	
+	collect(chunk) {
+		if (this.isBuffer)
+			this.data = Buffer.concat([ this.data, chunk ]);
+		else
+			this.data += chunk;
+		
+	},
+	
+	async done() {
+		
+		if (this.streams) {
+			const promises = [];
+			
+			for (const stream of this.streams) {
+				stream.push(null);
+				promises.push(stream.promise);
+			}
+			
+			await Promise.all(promises);
+		}
+		
+	}
+};
+
+
+class NodeIncomingTransfer extends IncomingTransfer {
+	
+	static methods = {
+		
+		stream: streamMethod,
+		
+		file: streamMethod,
+		
+		...IncomingTransfer.methods
+		
+	};
+	
+}
+
+class NodeIncomingTransport extends IncomingTransport {
+	
+	static IncomingTransfer = NodeIncomingTransfer;
+	
+}
+
+
+export { NodeIncomingTransfer as IncomingTransfer,
+	NodeIncomingTransport as IncomingTransport };

package/lib/node/index.js

@@ -0,0 +1,2 @@
+export * from "./incoming";
+export * from "./outgoing";

package/lib/node/outgoing.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import path from "node:path";
+import mime from "mime";
+import { OutgoingTransfer } from "../OutgoingTransfer";
+import { OutgoingTransport } from "../OutgoingTransport";
+
+
+class NodeOutgoingTransfer extends OutgoingTransfer {
+	
+	static methods = [
+		
+		[ "stream", data => typeof data == "object" && typeof data.on == "function" && typeof data.read == "function", {
+			
+			setup() {
+				
+				this.stream = this.data;
+				
+				if (!this.encoding)
+					this.encoding = "buffer";
+				
+				if (this.encoding === "buffer")
+					this.isBuffer = true;
+				
+			},
+			
+			confirm() {
+				
+				this.stream.on("data", this.handleChunk);
+				if (!this.size)
+					this.stream.on("end", this.sent);
+				
+			},
+			
+			transformChunk(chunk) {
+				return (this.isBuffer ? chunk : Buffer.from(chunk, this.encoding)).toString("base64");
+			}
+		} ],
+		
+		[ "file", data => typeof data == "string" && /^(\/|(\/[^/]+)+)$/.test(data), {
+			
+			async setup() {
+				
+				const fileName = this.data;
+				const name = path.basename(fileName);
+				const { size, mtimeMs: modifiedAt } = await fs.promises.stat(fileName);
+				
+				const metadata = {
+					name,
+					type: mime.getType(path.extname(name).slice(1)),
+					size,
+					modifiedAt
+				};
+				
+				this.stream = fs.createReadStream(fileName);
+				
+				this.size = size;
+				this.encoding = "buffer";
+				
+				if (this.metadata)
+					Object.assign(this.metadata, metadata);
+				else
+					this.metadata = metadata;
+				
+			},
+			
+			confirm() {
+				
+				this.stream.on("data", this.handleChunk);
+				
+			},
+			
+			transformChunk(chunk) {
+				return chunk.toString("base64");
+			}
+		} ],
+		
+		...OutgoingTransfer.methods
+		
+	];
+	
+}
+
+class NodeOutgoingTransport extends OutgoingTransport {
+	
+	static OutgoingTransfer = NodeOutgoingTransfer;
+	
+}
+
+
+export { NodeOutgoingTransfer as OutgoingTransfer,
+	NodeOutgoingTransport as OutgoingTransport };

package/package.json

@@ -0,0 +1,41 @@
+{
+	"name": "insite-ws-transfers",
+	"version": "1.0.465",
+	"description": "inSite file transfers over WebSockets",
+	"type": "module",
+	"main": "./lib/node/index.js",
+	"module": "./lib/node/index.js",
+	"exports": {
+		".": "./lib/node/index.js",
+		"./node": "./lib/node/index.js",
+		"./node/incoming": "./lib/node/incoming.js",
+		"./node/outgoing": "./lib/node/outgoing.js",
+		"./browser": "./lib/browser/index.js",
+		"./browser/incoming": "./lib/browser/incoming.js",
+		"./browser/outgoing": "./lib/browser/outgoing.js"
+	},
+	"packageManager": "yarn@1.22.22",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nesvet/insite-ws-transfers.git"
+	},
+	"keywords": [
+		"insite",
+		"ws",
+		"websockets",
+		"files",
+		"transfers"
+	],
+	"author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
+	"license": "MIT",
+	"dependencies": {
+		"@nesvet/n": "^1",
+		"mime": "^2"
+	},
+	"devDependencies": {
+		"@nesvet/eslint-config": "^1"
+	}
+}