@centia-io/sdk 0.0.52 → 0.0.54

package/dist/centia-io-sdk.js

@@ -735,35 +735,94 @@ var Users = class {
 */
 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();
 	}
 };
 
@@ -2125,16 +2184,41 @@ var FileImport = class {
 	}
 	/**
 	* 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({