@centia-io/sdk 0.0.52 → 0.0.54

package/dist/centia-io-sdk.umd.js

@@ -741,35 +741,94 @@
 	*/
 	var Ws = class {
 		constructor(options) {
-			this.options = options;
-			this.options.wsClient = this.options?.wsClient ?? WebSocket;
+			this.ws = null;
+			this.listeners = {};
+			this.closed = false;
+			this.options = {
+				reconnect: true,
+				reconnectInterval: 3e3,
+				...options
+			};
+			this.options.wsClient = this.options.wsClient ?? WebSocket;
 		}
 		connect() {
-			const me = this;
+			this.closed = false;
+			this.doConnect();
+		}
+		disconnect() {
+			this.closed = true;
+			this.ws?.close();
+			this.ws = null;
+		}
+		subscribe(sub) {
+			this.send({
+				type: "subscription",
+				...sub
+			});
+		}
+		send(data) {
+			if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error("WebSocket is not connected");
+			this.ws.send(typeof data === "string" ? data : JSON.stringify(data));
+		}
+		on(event, listener) {
+			if (!this.listeners[event]) this.listeners[event] = [];
+			this.listeners[event].push(listener);
+			return () => this.off(event, listener);
+		}
+		off(event, listener) {
+			const arr = this.listeners[event];
+			if (!arr) return;
+			const idx = arr.indexOf(listener);
+			if (idx !== -1) arr.splice(idx, 1);
+		}
+		get connected() {
+			return this.ws?.readyState === WebSocket.OPEN;
+		}
+		emit(event, data) {
+			const arr = this.listeners[event];
+			if (!arr) return;
+			for (const fn of arr) fn(data);
+		}
+		doConnect() {
 			const { accessToken } = getTokens();
-			const connect = () => {
-				let queryString = `?token=` + accessToken;
-				if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
-				const WSClass = this.options.wsClient;
-				const ws = new WSClass(this.options.host + `/` + queryString);
-				ws.onopen = function() {
-					console.log("WebSocket connected!");
-				};
-				ws.onmessage = function(event) {
-					me.options.callBack(event.data);
-				};
-				ws.onclose = function(event) {
-					if (accessToken !== "") {
-						console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
-						setTimeout(connect, 3e3);
-					}
-				};
-				ws.onerror = function(err) {
-					console.error("WebSocket error observed:", err);
-					ws.close();
-				};
+			if (!accessToken) return;
+			let url = this.options.host + "/?token=" + encodeURIComponent(accessToken);
+			if (this.options.rels) url += "&rels=" + encodeURIComponent(this.options.rels);
+			const WSClass = this.options.wsClient;
+			const ws = new WSClass(url);
+			this.ws = ws;
+			ws.onopen = () => {
+				this.emit("open", void 0);
+			};
+			ws.onmessage = (event) => {
+				let msg;
+				try {
+					msg = JSON.parse(typeof event.data === "string" ? event.data : event.data.toString());
+				} catch {
+					return;
+				}
+				switch (msg.type) {
+					case "batch":
+						this.emit("batch", msg);
+						break;
+					case "subscription_ack":
+						this.emit("subscription_ack", msg);
+						break;
+					case "error":
+						this.emit("error", msg);
+						break;
+				}
+			};
+			ws.onclose = (event) => {
+				this.emit("close", {
+					code: event.code,
+					reason: event.reason
+				});
+				if (!this.closed && this.options.reconnect) setTimeout(() => this.doConnect(), this.options.reconnectInterval);
+			};
+			ws.onerror = () => {
+				ws.close();
 			};
-			if (accessToken !== "") connect();
 		}
 	};
 
@@ -2131,16 +2190,41 @@
 		}
 		/**
 		* Upload a file via multipart/form-data.
-		* In Node.js, pass a FormData instance. In browsers, pass a native FormData.
+		* When `options.chunkSize` is set, the file is split into chunks and uploaded
+		* sequentially. The server reassembles the file from the chunks.
 		*/
-		async postFileUpload(formData) {
-			return this.client.request({
+		async postFileUpload(formData, options) {
+			if (!options?.chunkSize) return this.client.request({
 				path: "api/v4/file/upload",
 				method: "POST",
 				body: formData,
 				contentType: null,
 				expectedStatus: 201
 			});
+			const file = formData.get("filename");
+			if (!file) throw new Error("FormData must contain a \"filename\" entry for chunked upload.");
+			const fileName = file instanceof File ? file.name : "upload";
+			const totalChunks = Math.ceil(file.size / options.chunkSize);
+			let result = { filename: "" };
+			for (let i = 0; i < totalChunks; i++) {
+				const start = i * options.chunkSize;
+				const end = Math.min(start + options.chunkSize, file.size);
+				const chunk = file.slice(start, end);
+				const chunkForm = new FormData();
+				chunkForm.append("filename", chunk, fileName);
+				result = await this.client.request({
+					path: "api/v4/file/upload",
+					method: "POST",
+					body: chunkForm,
+					contentType: null,
+					query: {
+						chunk: String(i),
+						chunks: String(totalChunks)
+					},
+					expectedStatus: 201
+				});
+			}
+			return result;
 		}
 		async postFileProcess(body) {
 			return this.client.request({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@centia-io/sdk",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "Centia-io TypeScript SDK",
   "author": "Martin Høgh",
   "license": "MIT",