@medievalrain/binance-ts 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1481,43 +1481,16 @@ declare class MalformedParamError extends ResponseError {
 }
 //#endregion
 //#region src/websocket/base/types.d.ts
-type ConnectionSuccessEvent = {
-  result: null;
-  id: number;
-};
-type ConnectionErrorEvent = {
-  result: null;
-  id: number;
-  status: number;
-  error: {
-    code: number;
-    msg: string;
-  };
-};
-type ConnectionEvent = ConnectionSuccessEvent | ConnectionErrorEvent;
-//#endregion
-//#region src/websocket/base/client.d.ts
-type WebsocketClientEventMap<MarketEvent extends object> = {
-  marketMessage: (data: MarketEvent) => void;
-  connectionMessage: (data: ConnectionEvent) => void;
-  error: (error: Error | ConnectionErrorEvent) => void;
-};
-declare class BinanceWebsocketClient<MarketEvent extends object> {
-  private socket;
-  private baseUrl;
-  private emitter;
-  private subscriptionId;
-  private subscriptions;
-  constructor(baseUrl: string);
-  private createSocket;
-  private sendMessage;
-  private parseEvent;
-  subscribe(...channels: string[]): Promise<void>;
-  unsubscribe(...channels: string[]): Promise<void>;
-  reconnect(): Promise<void>;
-  connect(): Promise<void>;
-  addEventListener<E extends keyof WebsocketClientEventMap<MarketEvent>>(event: E, callback: WebsocketClientEventMap<MarketEvent>[E], options?: AddEventListenerOptions): void;
-}
+type ChannelsMap = Record<string, {
+  messageSchema: object;
+  subscriptionOptions?: object;
+}>;
+type OptArgs<CM extends ChannelsMap, K extends keyof CM> = CM[K]["subscriptionOptions"] extends never | undefined ? [] : [options: CM[K]["subscriptionOptions"]];
+type WebsocketClient<CM extends ChannelsMap> = { [K in keyof CM]: {
+  subscribe: (symbols: string[], ...args: OptArgs<CM, K>) => Promise<void>;
+  unsubscribe: (symbols: string[], ...args: OptArgs<CM, K>) => Promise<void>;
+  addEventListener: (cb: (data: CM[K]["messageSchema"]) => void, options?: AddEventListenerOptions) => void;
+} };
 //#endregion
 //#region src/websocket/futures/types.d.ts
 type FuturesBookTickerEvent = {
@@ -1538,11 +1511,21 @@ type FuturesBookDepthEvent = {
   b: [string, string][];
   a: [string, string][];
 };
-type FuturesMarketEvent = FuturesBookDepthEvent | FuturesBookTickerEvent;
+type FuturesChannels = {
+  bookTicker: {
+    messageSchema: FuturesBookTickerEvent;
+    subscriptionOptions: never;
+  };
+  partialBookDepth: {
+    messageSchema: FuturesBookDepthEvent;
+    subscriptionOptions: {
+      levels: number;
+      updateSpeedMs?: number;
+    };
+  };
+};
 //#endregion
 //#region src/websocket/futures/client.d.ts
-declare class FuturesWebsocketClient extends BinanceWebsocketClient<FuturesMarketEvent> {
-  constructor(baseUrl?: string);
-}
+declare const createFuturesWebsocketClient: (baseUrl?: string) => WebsocketClient<FuturesChannels>;
 //#endregion
-export { ApiError, BinanceRestClient, ConnectionErrorEvent, ConnectionEvent, ConnectionSuccessEvent, ErrorMessageParsingError, FundingInfo, FundingInfoEntry, FundingRate, FundingRateEntry, FuturesAccountAsset, FuturesAccountBalance, FuturesAccountConfig, FuturesAccountInfo, FuturesAccountPosition, FuturesAssetIndex, FuturesBasis, FuturesBookDepthEvent, FuturesBookTicker, FuturesBookTickerEvent, FuturesCheckServerTime, FuturesCommissionRate, FuturesCompositeIndex, FuturesCompositeIndexAsset, FuturesContractType, FuturesDeliveryPrice, FuturesExchangeInfo, FuturesExchangeInfoAsset, FuturesExchangeInfoFilter, FuturesExchangeInfoRateLimit, FuturesExchangeInfoSymbol, FuturesIncomeHistory, FuturesIncomeType, FuturesIndexPriceConstituent, FuturesIndexPriceConstituents, FuturesInsuranceBalanceAsset, FuturesInsuranceBalanceEntry, FuturesKlineInterval, FuturesLeverageBracket, FuturesLeverageBracketEntry, FuturesLongShortRatio, FuturesMarketEvent, FuturesNewOrder, FuturesNewOrderRespType, FuturesOldTradesLookup, FuturesOpenInterest, FuturesOpenInterestPeriod, FuturesOpenInterestStats, FuturesOrderBook, FuturesOrderSide, FuturesOrderType, FuturesPositionMode, FuturesPositionSide, FuturesPriceMatch, FuturesRecentTrades, FuturesSelfTradePrevention, FuturesSymbolConfig, FuturesSymbolPrice, FuturesTakerBuySellRatio, FuturesTakerBuySellRatioItem, FuturesTestConnectivity, FuturesTicker24h, FuturesTimeInForce, FuturesUnderlyingType, FuturesUserRateLimit, FuturesWebsocketClient, FuturesWorkingType, FuturesggregateTrades, KlineData, MalformedParamError, MarkPrice, ResponseError, ValidationError, WeightError };
+export { ApiError, BinanceRestClient, ErrorMessageParsingError, FundingInfo, FundingInfoEntry, FundingRate, FundingRateEntry, FuturesAccountAsset, FuturesAccountBalance, FuturesAccountConfig, FuturesAccountInfo, FuturesAccountPosition, FuturesAssetIndex, FuturesBasis, FuturesBookDepthEvent, FuturesBookTicker, FuturesBookTickerEvent, FuturesCheckServerTime, FuturesCommissionRate, FuturesCompositeIndex, FuturesCompositeIndexAsset, FuturesContractType, FuturesDeliveryPrice, FuturesExchangeInfo, FuturesExchangeInfoAsset, FuturesExchangeInfoFilter, FuturesExchangeInfoRateLimit, FuturesExchangeInfoSymbol, FuturesIncomeHistory, FuturesIncomeType, FuturesIndexPriceConstituent, FuturesIndexPriceConstituents, FuturesInsuranceBalanceAsset, FuturesInsuranceBalanceEntry, FuturesKlineInterval, FuturesLeverageBracket, FuturesLeverageBracketEntry, FuturesLongShortRatio, FuturesNewOrder, FuturesNewOrderRespType, FuturesOldTradesLookup, FuturesOpenInterest, FuturesOpenInterestPeriod, FuturesOpenInterestStats, FuturesOrderBook, FuturesOrderSide, FuturesOrderType, FuturesPositionMode, FuturesPositionSide, FuturesPriceMatch, FuturesRecentTrades, FuturesSelfTradePrevention, FuturesSymbolConfig, FuturesSymbolPrice, FuturesTakerBuySellRatio, FuturesTakerBuySellRatioItem, FuturesTestConnectivity, FuturesTicker24h, FuturesTimeInForce, FuturesUnderlyingType, FuturesUserRateLimit, FuturesWorkingType, FuturesggregateTrades, KlineData, MalformedParamError, MarkPrice, ResponseError, ValidationError, WeightError, createFuturesWebsocketClient };

package/dist/index.js

@@ -1033,7 +1033,7 @@ var BinanceRestClient = class {
 };
 
 //#endregion
-//#region src/websocket/typed-event-emitter.ts
+//#region src/websocket/base/typed-event-emitter.ts
 var Emitter = class {
 	eventTarget = new EventTarget();
 	addEventListener(event, callback, options) {
@@ -1046,129 +1046,161 @@ var Emitter = class {
 
 //#endregion
 //#region src/websocket/base/client.ts
-var BinanceWebsocketClient = class {
-	socket;
-	baseUrl;
-	emitter = new Emitter();
-	subscriptionId = 1;
-	subscriptions = /* @__PURE__ */ new Map();
-	constructor(baseUrl) {
-		this.parseEvent = this.parseEvent.bind(this);
-		this.baseUrl = baseUrl;
-		this.socket = this.createSocket();
-	}
-	createSocket() {
-		if (this.socket) {
-			this.socket.removeEventListener("message", this.parseEvent);
-			this.socket.close();
-		}
-		const socket = new WebSocket(this.baseUrl);
-		socket.addEventListener("message", this.parseEvent);
-		return socket;
-	}
-	sendMessage(data) {
-		this.socket.send(JSON.stringify(data));
-	}
-	parseEvent(e) {
+const makeSection = (baseUrl) => {
+	let socket = new WebSocket(baseUrl);
+	let connectionController = new AbortController();
+	const subscriptions = /* @__PURE__ */ new Map();
+	const emitter = new Emitter();
+	let connectionId = 1;
+	const parseMessageEvent = (e) => {
 		if (typeof e.data !== "string") {
-			this.emitter.emit("error", new Error("Message event is not a string", { cause: e.data }));
+			emitter.emit("error", new Error("Message event is not a string", { cause: e.data }));
 			return;
 		}
 		const data = JSON.parse(e.data);
-		if ("id" in data) this.emitter.emit("connectionMessage", data);
-		else this.emitter.emit("marketMessage", data);
-	}
-	async subscribe(...channels) {
-		await this.connect();
-		const pendingChannels = [];
-		for (const channel of channels) if (!this.subscriptions.get(channel)) {
-			pendingChannels.push(channel);
-			this.subscriptions.set(channel, "PENDING_SUBSCRIPTION");
-		}
-		const id = this.subscriptionId;
-		const data = {
+		if ("id" in data) emitter.emit("connectionMessage", data);
+		else emitter.emit("marketMessage", data);
+	};
+	socket.addEventListener("message", parseMessageEvent, { signal: connectionController.signal });
+	const sendMessage = (data) => socket.send(JSON.stringify(data));
+	const connect = async () => {
+		return new Promise((resolve) => {
+			if (socket.readyState === WebSocket.OPEN) return resolve();
+			if (socket.readyState === WebSocket.CLOSED) {
+				connectionController.abort();
+				socket = new WebSocket(baseUrl);
+				connectionController = new AbortController();
+				socket.addEventListener("message", parseMessageEvent, { signal: connectionController.signal });
+				connectionId = 1;
+				const toSubscribe = Array.from(subscriptions.entries()).filter(([_, state]) => state !== "PENDING_UNSUBSCRIPTION").map(([key]) => key);
+				return subscribe(toSubscribe);
+			}
+			if (socket.readyState === WebSocket.CONNECTING) socket.addEventListener("open", () => resolve(), { once: true });
+			if (socket.readyState === WebSocket.CLOSING) socket.addEventListener("close", async () => {
+				await connect();
+				resolve();
+			}, { once: true });
+		});
+	};
+	const subscribe = async (symbols) => {
+		await connect();
+		const toSubscribe = [];
+		const delayed = [];
+		connectionId += 1;
+		const currentId = connectionId;
+		symbols.forEach((symbol) => {
+			const existing = subscriptions.get(symbol);
+			if (!existing) {
+				toSubscribe.push(symbol);
+				subscriptions.set(symbol, "PENDING_SUBSCRIPTION");
+				return;
+			}
+			if (existing === "SUBSCRIBED") return;
+			delayed.push(symbol);
+		});
+		sendMessage({
 			method: "SUBSCRIBE",
-			params: pendingChannels,
-			id
-		};
-		this.subscriptionId += 1;
-		this.sendMessage(data);
-		return new Promise((resolve, reject) => {
+			params: toSubscribe,
+			id: currentId
+		});
+		await new Promise((resolve, reject) => {
 			const controller = new AbortController();
-			const handler = (data$1) => {
-				if (data$1.id !== id) return;
+			const handleSubscription = (data) => {
+				if (data.id !== currentId) return;
 				controller.abort();
-				if ("error" in data$1) {
-					for (const channel of pendingChannels) if (this.subscriptions.get(channel) === "PENDING_SUBSCRIPTION") this.subscriptions.delete(channel);
-					this.emitter.emit("error", data$1);
-					reject(/* @__PURE__ */ new Error(`Subscription ${id} failed`));
-				} else {
-					pendingChannels.forEach((channel) => this.subscriptions.set(channel, "SUBSCRIBED"));
-					resolve();
+				if ("error" in data) return reject();
+				else {
+					toSubscribe.forEach((symbol) => subscriptions.set(symbol, "SUBSCRIBED"));
+					return resolve();
 				}
 			};
-			this.emitter.addEventListener("connectionMessage", handler, { signal: controller.signal });
+			emitter.addEventListener("connectionMessage", handleSubscription, { signal: controller.signal });
 		});
-	}
-	async unsubscribe(...channels) {
-		await this.connect();
-		const id = this.subscriptionId;
-		const pendingChannels = [];
-		for (const channel of channels) if (this.subscriptions.get(channel) !== "PENDING_UNSUBSCRIPTION") {
-			pendingChannels.push(channel);
-			this.subscriptions.set(channel, "PENDING_UNSUBSCRIPTION");
-		}
-		const data = {
+		if (delayed.length) return subscribe(delayed);
+	};
+	const unsubscribe = async (symbols) => {
+		await connect();
+		const toUnsubscribe = [];
+		const delayed = [];
+		connectionId += 1;
+		const currentId = connectionId;
+		symbols.forEach((symbol) => {
+			if (subscriptions.get(symbol) === "SUBSCRIBED") {
+				toUnsubscribe.push(symbol);
+				subscriptions.set(symbol, "PENDING_UNSUBSCRIPTION");
+				return;
+			}
+			delayed.push(symbol);
+		});
+		sendMessage({
 			method: "UNSUBSCRIBE",
-			params: pendingChannels,
-			id
-		};
-		this.subscriptionId += 1;
-		this.sendMessage(data);
-		return new Promise((resolve, reject) => {
+			params: toUnsubscribe,
+			id: currentId
+		});
+		await new Promise((resolve, reject) => {
 			const controller = new AbortController();
-			const handler = (data$1) => {
-				if (data$1.id !== id) return;
+			const handleSubscription = (data) => {
+				if (data.id !== currentId) return;
 				controller.abort();
-				if ("error" in data$1) {
-					for (const channel of pendingChannels) if (this.subscriptions.get(channel) === "PENDING_UNSUBSCRIPTION") this.subscriptions.set(channel, "SUBSCRIBED");
-					this.emitter.emit("error", data$1);
-					reject(/* @__PURE__ */ new Error(`Unsubscription ${id} failed`));
-				} else {
-					pendingChannels.forEach((channel) => this.subscriptions.delete(channel));
-					resolve();
+				if ("error" in data) return reject();
+				else {
+					toUnsubscribe.forEach((symbol) => subscriptions.delete(symbol));
+					return resolve();
 				}
 			};
-			this.emitter.addEventListener("connectionMessage", handler, { signal: controller.signal });
+			emitter.addEventListener("connectionMessage", handleSubscription, { signal: controller.signal });
 		});
-	}
-	async reconnect() {
-		this.socket = this.createSocket();
-		await this.connect();
-		const toRestore = [];
-		for (const [channel, state] of this.subscriptions) if (state !== "PENDING_UNSUBSCRIPTION") toRestore.push(channel);
-		if (toRestore.length) await this.subscribe(...toRestore);
-	}
-	async connect() {
-		if (this.socket.readyState === WebSocket.OPEN) return;
-		if (this.socket.readyState === WebSocket.CONNECTING) return new Promise((resolve, reject) => {
-			this.socket.addEventListener("open", () => resolve(), { once: true });
-			this.socket.addEventListener("close", () => reject(), { once: true });
+		if (delayed.length) return unsubscribe(delayed);
+	};
+	return {
+		socket,
+		subscriptions,
+		connectionId,
+		addEventListener: emitter.addEventListener.bind(emitter),
+		subscribe,
+		unsubscribe
+	};
+};
+const createWebsocketClient = (baseUrl, symbolConverter$1) => {
+	const sections = /* @__PURE__ */ new Map();
+	const getSection = (channel) => {
+		const existingSection = sections.get(channel);
+		if (existingSection) return existingSection;
+		const section = makeSection(baseUrl);
+		sections.set(channel, section);
+		return section;
+	};
+	return new Proxy({}, { get(_target, channel) {
+		const section = getSection(channel);
+		const converter = symbolConverter$1[channel];
+		return Object.freeze({
+			subscribe: (symbols, ...args) => {
+				return section.subscribe(symbols.map((s) => converter(s, ...args)));
+			},
+			unsubscribe: (symbols, ...args) => {
+				return section.unsubscribe(symbols.map((s) => converter(s, ...args)));
+			},
+			addEventListener: (callback, options) => {
+				section.addEventListener("marketMessage", callback, options);
+			}
 		});
-		return this.reconnect();
-	}
-	addEventListener(event, callback, options) {
-		this.emitter.addEventListener(event, callback, options);
-	}
+	} });
 };
 
 //#endregion
 //#region src/websocket/futures/client.ts
-var FuturesWebsocketClient = class extends BinanceWebsocketClient {
-	constructor(baseUrl = "wss://stream.binance.com:9443/ws") {
-		super(baseUrl);
+const symbolConverter = {
+	bookTicker: (symbol) => {
+		return `${symbol.toLowerCase()}@bookTicker`;
+	},
+	partialBookDepth: (symbol, { levels, updateSpeedMs }) => {
+		if (updateSpeedMs) return `${symbol.toLowerCase()}@depth${levels}@${updateSpeedMs}ms`;
+		return `${symbol.toLowerCase()}@depth${levels}`;
 	}
 };
+const createFuturesWebsocketClient = (baseUrl = "wss://stream.binance.com:9443/ws") => {
+	return createWebsocketClient(baseUrl, symbolConverter);
+};
 
 //#endregion
-export { ApiError, BinanceRestClient, ErrorMessageParsingError, FuturesWebsocketClient, MalformedParamError, ResponseError, ValidationError, WeightError };
+export { ApiError, BinanceRestClient, ErrorMessageParsingError, MalformedParamError, ResponseError, ValidationError, WeightError, createFuturesWebsocketClient };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@medievalrain/binance-ts",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "Binance API SDK",
 	"access": "public",
 	"type": "module",
@@ -23,20 +23,21 @@
 	"devDependencies": {
 		"date-fns": "4.1.0",
 		"dotenv": "17.2.2",
-		"oxlint": "1.14.0",
+		"oxlint": "1.15.0",
 		"prettier": "3.6.2",
-		"tsdown": "0.15.0",
+		"tsdown": "0.15.1",
 		"typescript": "5.9.2",
 		"vitest": "3.2.4",
 		"@types/node": "24.3.1"
 	},
 	"peerDependencies": {
-		"zod": "4"
+		"zod": "^4"
 	},
 	"dependencies": {
 		"undici": "7.16.0"
 	},
 	"engines": {
 		"node": ">=22.19.0"
-	}
+	},
+	"packageManager": "pnpm@10.16.0"
 }