@nemnesia/symbol-websocket 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# 変更履歴
+
+このプロジェクトにおけるすべての重要な変更は、このファイルに記録されます。
+
+変更履歴のフォーマットは[変更履歴の管理](https://keepachangelog.com/en/1.0.0/)に基づいています。
+
+## [0.1.0] - 2025/12/29
+
+### 追加
+
+- Symbol ブロックチェーンのWebSocket接続をサポート。
+- リアルタイムデータ取得機能（ブロック、トランザクション、アカウント情報など）。
+- 柔軟なサブスクリプション管理機能。
+- 自動再接続機能とサブスクリプション復元機能。
+- エラーおよびクローズイベントのハンドリング機能。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ccHarvestasya
+
+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,101 @@
+# Symbol WebSocket
+
+Symbol WebSocket は、Symbol ブロックチェーンのリアルタイムデータを監視するための TypeScript ライブラリです。このライブラリは、WebSocket を使用してブロックチェーンデータを効率的に取得し、サブスクリプションベースのイベントリスニングを提供します。
+
+## 特徴
+
+- **リアルタイムデータ取得**: ブロック、トランザクション、アカウント情報などをリアルタイムで取得可能。
+- **柔軟なサブスクリプション管理**: 必要なチャネルに簡単にサブスクライブおよびアンサブスクライブ可能。
+- **エラーおよびクローズイベントのハンドリング**: WebSocket のエラーや接続終了を簡単に処理可能。
+- **自動再接続**: 接続が切断された場合、自動的に再接続し、サブスクリプションを復元。
+
+## インストール
+
+```bash
+npm install @nemnesia/symbol-websocket
+```
+
+## 使い方
+
+```typescript
+import { SymbolWebSocket } from '@nemnesia/symbol-websocket';
+
+const ws = new SymbolWebSocket({
+  host: 'localhost',
+  ssl: true,
+  timeout: 5000,
+});
+
+// チャネルにサブスクライブ
+ws.on('confirmedAdded', (message) => {
+  console.log('New confirmed transaction:', message);
+});
+
+// エラーイベントの登録
+ws.onError((err) => {
+  console.error('WebSocket error:', err);
+});
+
+// クローズイベントの登録
+ws.onClose((event) => {
+  console.log('WebSocket closed:', event);
+});
+
+// 切断
+ws.disconnect();
+```
+
+## API
+
+#### コンストラクタ
+
+```typescript
+new SymbolWebSocket(options: SymbolWebSocketOptions);
+```
+
+- `options`: 接続設定。
+  - `host`: 接続先ホスト。
+  - `ssl`: SSL を使用するかどうか。
+  - `timeout`: 接続タイムアウト（ミリ秒）。指定時間内に接続が完了しない場合はエラーになります。
+  - `autoReconnect`: 自動再接続を有効にするか（デフォルト: `true`）。
+  - `maxReconnectAttempts`: 最大再接続試行回数（デフォルト: `Infinity`）。
+  - `reconnectInterval`: 再接続の間隔（ミリ秒、デフォルト: `3000`）。
+
+#### メソッド
+
+- `on(channel: SymbolChannel, callback: (message: WebSocket.MessageEvent) => void): void`
+  - 指定したチャネルにサブスクライブします。
+- `on(channel: SymbolChannel, address: string, callback: (message: WebSocket.MessageEvent) => void): void`
+  - アドレスを指定してチャネルにサブスクライブします。
+- `off(channel: SymbolChannel): void`
+  - 指定したチャネルのサブスクリプションを解除します。
+- `off(channel: SymbolChannel, address: string): void`
+  - アドレスを指定してチャネルのサブスクリプションを解除します。
+- `onConnect(callback: (uid: string) => void): void`
+  - WebSocket 接続完了時のコールバックを登録します。
+- `onReconnect(callback: (attemptCount: number) => void): void`
+  - 再接続試行時のコールバックを登録します。
+- `onError(callback: (err: WebSocket.ErrorEvent) => void): void`
+  - エラーイベントのコールバックを登録します。
+- `onClose(callback: (event: WebSocket.CloseEvent) => void): void`
+  - クローズイベントのコールバックを登録します。
+- `disconnect(): void`
+  - WebSocket 接続を切断します。
+
+## 注意点
+
+- 再接続は自動的に行われます（デフォルト有効）。
+- 再接続時は既存のサブスクリプションが自動的に復元されます。
+- `autoReconnect: false`を設定することで自動再接続を無効化できます。
+
+## ライセンス
+
+このプロジェクトは [MITライセンス](./LICENSE) のもとで公開されています。
+
+## 貢献方法
+
+バグ報告・機能要望・プルリクエストは [GitHubリポジトリ](https://github.com/nemnesia/symbol-tools/tree/main/packages/symbol-websocket) で受け付けています。お気軽にご参加ください。
+
+## バグ報告・質問
+
+問題や質問は [GitHub Issues](https://github.com/nemnesia/symbol-tools/issues) からご連絡ください。

package/dist/index.cjs

@@ -0,0 +1,284 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SymbolWebSocket: () => SymbolWebSocket,
+  symbolChannelPaths: () => symbolChannelPaths
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/symbolChannelPaths.ts
+var symbolChannelPaths = {
+  block: { subscribe: () => "block" },
+  finalizedBlock: { subscribe: () => "finalizedBlock" },
+  confirmedAdded: { subscribe: (address) => address ? `confirmedAdded/${address}` : "confirmedAdded" },
+  unconfirmedAdded: { subscribe: (address) => address ? `unconfirmedAdded/${address}` : "unconfirmedAdded" },
+  unconfirmedRemoved: {
+    subscribe: (address) => address ? `unconfirmedRemoved/${address}` : "unconfirmedRemoved"
+  },
+  partialAdded: { subscribe: (address) => address ? `partialAdded/${address}` : "partialAdded" },
+  partialRemoved: { subscribe: (address) => address ? `partialRemoved/${address}` : "partialRemoved" },
+  cosignature: { subscribe: (address) => address ? `cosignature/${address}` : "cosignature" },
+  status: { subscribe: (address) => address ? `status/${address}` : "status" }
+};
+
+// src/SymbolWebSocket.ts
+var import_isomorphic_ws = __toESM(require("isomorphic-ws"), 1);
+var WS_OPEN = import_isomorphic_ws.default.OPEN ?? 1;
+var WS_CONNECTING = import_isomorphic_ws.default.CONNECTING ?? 0;
+var SymbolWebSocket = class {
+  _client;
+  _uid = null;
+  isFirstMessage = true;
+  eventCallbacks = {};
+  pendingSubscribes = [];
+  errorCallbacks = [];
+  onCloseCallback = () => {
+  };
+  connectCallbacks = [];
+  reconnectCallbacks = [];
+  // 再接続関連のプロパティ
+  options;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  connectionTimeoutTimer = null;
+  isManualDisconnect = false;
+  activeSubscriptions = /* @__PURE__ */ new Set();
+  /**
+   * コンストラクタ
+   * @param options Symbolウェブソケットオプション
+   */
+  constructor(options) {
+    this.options = {
+      autoReconnect: true,
+      maxReconnectAttempts: Infinity,
+      reconnectInterval: 3e3,
+      ...options
+    };
+    this.createConnection();
+  }
+  /**
+   * WebSocket接続を作成
+   */
+  createConnection() {
+    const endPointHost = this.options.host;
+    const ssl = this.options.ssl ?? false;
+    const protocol = ssl ? "wss" : "ws";
+    const endPointPort = ssl ? "3001" : "3000";
+    this._client = new import_isomorphic_ws.default(`${protocol}://${endPointHost}:${endPointPort}/ws`);
+    if (this.options.timeout) {
+      this.connectionTimeoutTimer = setTimeout(() => {
+        if (this._client.readyState === WS_CONNECTING || !this._uid) {
+          const timeoutError = new Error(`WebSocket connection timeout after ${this.options.timeout}ms`);
+          const errorEvent = { error: timeoutError, message: timeoutError.message };
+          this.errorCallbacks.forEach((cb) => cb(errorEvent));
+          this._client.close();
+        }
+      }, this.options.timeout);
+    }
+    this._client.onclose = (event) => {
+      this.onCloseCallback(event);
+      if (!this.isManualDisconnect && this.options.autoReconnect) {
+        this.attemptReconnect();
+      }
+    };
+    this._client.onerror = (err) => {
+      this.errorCallbacks.forEach((cb) => cb(err));
+    };
+    this._client.onmessage = (message) => {
+      try {
+        const data = JSON.parse(message.data.toString());
+        if (this.isFirstMessage) {
+          if (data.uid) {
+            this._uid = data.uid;
+            this.reconnectAttempts = 0;
+            if (this.connectionTimeoutTimer) {
+              clearTimeout(this.connectionTimeoutTimer);
+              this.connectionTimeoutTimer = null;
+            }
+            this.connectCallbacks.forEach((cb) => cb(this._uid));
+            this.activeSubscriptions.forEach((subscribePath) => {
+              this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+            });
+            this.pendingSubscribes.forEach(({ subscribePath }) => {
+              this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+              this.activeSubscriptions.add(subscribePath);
+            });
+            this.pendingSubscribes = [];
+          }
+          this.isFirstMessage = false;
+          return;
+        }
+        const channel = data.topic;
+        if (channel && this.eventCallbacks[channel]) {
+          this.eventCallbacks[channel].forEach((cb) => cb(data));
+        }
+      } catch (e) {
+        if (this.errorCallbacks.length > 0) {
+          const errorEvent = { ...e instanceof Error ? e : { message: String(e) } };
+          this.errorCallbacks.forEach((cb) => cb(errorEvent));
+        } else {
+          throw e;
+        }
+      }
+    };
+  }
+  /**
+   * 再接続を試みる
+   */
+  attemptReconnect() {
+    const maxAttempts = this.options.maxReconnectAttempts ?? Infinity;
+    if (this.reconnectAttempts >= maxAttempts) {
+      return;
+    }
+    this.reconnectAttempts++;
+    this.reconnectCallbacks.forEach((cb) => cb(this.reconnectAttempts));
+    const interval = this.options.reconnectInterval ?? 3e3;
+    this.reconnectTimer = setTimeout(() => {
+      this.isFirstMessage = true;
+      this._uid = null;
+      this.createConnection();
+    }, interval);
+  }
+  /**
+   * WebSocket接続完了イベント登録
+   * @param callback 接続時に呼ばれるコールバック
+   */
+  onConnect(callback) {
+    this.connectCallbacks.push(callback);
+    if (this._uid) {
+      callback(this._uid);
+    }
+  }
+  /**
+   * WebSocket再接続イベント登録
+   * @param callback 再接続試行時に呼ばれるコールバック
+   */
+  onReconnect(callback) {
+    this.reconnectCallbacks.push(callback);
+  }
+  /**
+   * UID
+   */
+  get uid() {
+    return this._uid;
+  }
+  /**
+   * クライアントインスタンスを取得
+   */
+  get client() {
+    return this._client;
+  }
+  /**
+   * 接続状態を取得
+   */
+  get isConnected() {
+    return this._client.readyState === WS_OPEN;
+  }
+  /**
+   * WebSocketエラーイベント登録
+   * @param callback エラー時に呼ばれるコールバック
+   */
+  onError(callback) {
+    this.errorCallbacks.push(callback);
+  }
+  /**
+   * WebSocketクローズイベント登録
+   * @param callback クローズ時に呼ばれるコールバック
+   */
+  onClose(callback) {
+    this.onCloseCallback = callback;
+  }
+  on(channel, addressOrCallback, callback) {
+    const address = typeof addressOrCallback === "string" ? addressOrCallback : void 0;
+    const actualCallback = typeof addressOrCallback === "function" ? addressOrCallback : callback;
+    const channelPath = symbolChannelPaths[channel];
+    const subscribePath = typeof channelPath.subscribe === "function" ? channelPath.subscribe(address) : channelPath.subscribe;
+    if (!subscribePath) {
+      throw new Error(`Subscribe path could not be determined for channel: ${channel}`);
+    }
+    if (!this.eventCallbacks[subscribePath]) {
+      this.eventCallbacks[subscribePath] = [];
+    }
+    this.eventCallbacks[subscribePath].push(actualCallback);
+    if (!this._uid) {
+      this.pendingSubscribes.push({ subscribePath, callback: actualCallback });
+      return;
+    }
+    if (this._client.readyState === WS_OPEN) {
+      this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+      this.activeSubscriptions.add(subscribePath);
+    }
+  }
+  off(channel, address) {
+    const channelPath = symbolChannelPaths[channel];
+    const subscribePath = typeof channelPath.subscribe === "function" ? channelPath.subscribe(address) : channelPath.subscribe;
+    if (!subscribePath) {
+      throw new Error(`Subscribe path could not be determined for channel: ${channel}`);
+    }
+    delete this.eventCallbacks[subscribePath];
+    this.activeSubscriptions.delete(subscribePath);
+    if (this._uid && this._client.readyState === WS_OPEN) {
+      this._client.send(JSON.stringify({ uid: this._uid, unsubscribe: subscribePath }));
+    }
+  }
+  /**
+   * WebSocket接続を切断
+   */
+  disconnect() {
+    this.isManualDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.connectionTimeoutTimer) {
+      clearTimeout(this.connectionTimeoutTimer);
+      this.connectionTimeoutTimer = null;
+    }
+    this.eventCallbacks = {};
+    this.pendingSubscribes = [];
+    this.errorCallbacks = [];
+    this.connectCallbacks = [];
+    this.reconnectCallbacks = [];
+    this.activeSubscriptions.clear();
+    if (this._client.readyState === WS_OPEN || this._client.readyState === WS_CONNECTING) {
+      this._client.close();
+    }
+    this._uid = null;
+    this.isFirstMessage = true;
+    this.reconnectAttempts = 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SymbolWebSocket,
+  symbolChannelPaths
+});

package/dist/index.d.cts

@@ -0,0 +1,144 @@
+import WebSocket from 'isomorphic-ws';
+
+/**
+ * Symbolチャネルタイプ
+ * - block: 生成されたブロックの通知
+ * - finalizedBlock: ファイナライズ通知
+ * - confirmedAdded: 承認トランザクション通知
+ * - unconfirmedAdded: 未承認トランザクション通知
+ * - unconfirmedRemoved: 未承認トランザクション削除通知
+ * - partialAdded: パーシャル追加通知
+ * - partialRemoved: パーシャル削除通知
+ * - cosignature: 連署要求通知
+ * - status: ステータス通知
+ */
+type SymbolChannel = 'block' | 'finalizedBlock' | 'confirmedAdded' | 'unconfirmedAdded' | 'unconfirmedRemoved' | 'partialAdded' | 'partialRemoved' | 'cosignature' | 'status';
+/**
+ * Symbolチャネルパス定義
+ */
+declare const symbolChannelPaths: Record<SymbolChannel, {
+    subscribe: (address?: string) => string;
+}>;
+
+/**
+ * Symbolウェブソケットモニターオプション
+ */
+interface SymbolWebSocketOptions {
+    host: string;
+    /**
+     * 接続タイムアウト（ミリ秒）
+     */
+    timeout?: number;
+    ssl?: boolean;
+    /**
+     * 自動再接続を有効にする
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * 最大再接続試行回数
+     * @default Infinity
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * 再接続間隔（ミリ秒）
+     * @default 3000
+     */
+    reconnectInterval?: number;
+}
+
+/**
+ * Symbolウェブソケットクラス
+ */
+declare class SymbolWebSocket {
+    private _client;
+    private _uid;
+    private isFirstMessage;
+    private eventCallbacks;
+    private pendingSubscribes;
+    private errorCallbacks;
+    private onCloseCallback;
+    private connectCallbacks;
+    private reconnectCallbacks;
+    private options;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private connectionTimeoutTimer;
+    private isManualDisconnect;
+    private activeSubscriptions;
+    /**
+     * コンストラクタ
+     * @param options Symbolウェブソケットオプション
+     */
+    constructor(options: SymbolWebSocketOptions);
+    /**
+     * WebSocket接続を作成
+     */
+    private createConnection;
+    /**
+     * 再接続を試みる
+     */
+    private attemptReconnect;
+    /**
+     * WebSocket接続完了イベント登録
+     * @param callback 接続時に呼ばれるコールバック
+     */
+    onConnect(callback: (uid: string) => void): void;
+    /**
+     * WebSocket再接続イベント登録
+     * @param callback 再接続試行時に呼ばれるコールバック
+     */
+    onReconnect(callback: (attemptCount: number) => void): void;
+    /**
+     * UID
+     */
+    get uid(): string | null;
+    /**
+     * クライアントインスタンスを取得
+     */
+    get client(): WebSocket;
+    /**
+     * 接続状態を取得
+     */
+    get isConnected(): boolean;
+    /**
+     * WebSocketエラーイベント登録
+     * @param callback エラー時に呼ばれるコールバック
+     */
+    onError(callback: (err: WebSocket.ErrorEvent) => void): void;
+    /**
+     * WebSocketクローズイベント登録
+     * @param callback クローズ時に呼ばれるコールバック
+     */
+    onClose(callback: (event: WebSocket.CloseEvent) => void): void;
+    /**
+     * チャネルサブスクメソッド
+     * @param channel チャネル名
+     * @param callback コールバック関数
+     */
+    on(channel: SymbolChannel, callback: (message: WebSocket.MessageEvent) => void): void;
+    /**
+     * チャネルサブスクメソッド
+     * @param channel チャネル名
+     * @param address アドレス
+     * @param callback コールバック関数
+     */
+    on(channel: SymbolChannel, address: string, callback: (message: WebSocket.MessageEvent) => void): void;
+    /**
+     * チャネルアンサブスクメソッド
+     * @param channel チャネル名
+     */
+    off(channel: SymbolChannel): void;
+    /**
+     * チャネルアンサブスクメソッド
+     * @param channel チャネル名
+     * @param address アドレス
+     */
+    off(channel: SymbolChannel, address: string): void;
+    /**
+     * WebSocket接続を切断
+     */
+    disconnect(): void;
+}
+
+export { type SymbolChannel, SymbolWebSocket, type SymbolWebSocketOptions, symbolChannelPaths };

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import WebSocket from 'isomorphic-ws';
+
+/**
+ * Symbolチャネルタイプ
+ * - block: 生成されたブロックの通知
+ * - finalizedBlock: ファイナライズ通知
+ * - confirmedAdded: 承認トランザクション通知
+ * - unconfirmedAdded: 未承認トランザクション通知
+ * - unconfirmedRemoved: 未承認トランザクション削除通知
+ * - partialAdded: パーシャル追加通知
+ * - partialRemoved: パーシャル削除通知
+ * - cosignature: 連署要求通知
+ * - status: ステータス通知
+ */
+type SymbolChannel = 'block' | 'finalizedBlock' | 'confirmedAdded' | 'unconfirmedAdded' | 'unconfirmedRemoved' | 'partialAdded' | 'partialRemoved' | 'cosignature' | 'status';
+/**
+ * Symbolチャネルパス定義
+ */
+declare const symbolChannelPaths: Record<SymbolChannel, {
+    subscribe: (address?: string) => string;
+}>;
+
+/**
+ * Symbolウェブソケットモニターオプション
+ */
+interface SymbolWebSocketOptions {
+    host: string;
+    /**
+     * 接続タイムアウト（ミリ秒）
+     */
+    timeout?: number;
+    ssl?: boolean;
+    /**
+     * 自動再接続を有効にする
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * 最大再接続試行回数
+     * @default Infinity
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * 再接続間隔（ミリ秒）
+     * @default 3000
+     */
+    reconnectInterval?: number;
+}
+
+/**
+ * Symbolウェブソケットクラス
+ */
+declare class SymbolWebSocket {
+    private _client;
+    private _uid;
+    private isFirstMessage;
+    private eventCallbacks;
+    private pendingSubscribes;
+    private errorCallbacks;
+    private onCloseCallback;
+    private connectCallbacks;
+    private reconnectCallbacks;
+    private options;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private connectionTimeoutTimer;
+    private isManualDisconnect;
+    private activeSubscriptions;
+    /**
+     * コンストラクタ
+     * @param options Symbolウェブソケットオプション
+     */
+    constructor(options: SymbolWebSocketOptions);
+    /**
+     * WebSocket接続を作成
+     */
+    private createConnection;
+    /**
+     * 再接続を試みる
+     */
+    private attemptReconnect;
+    /**
+     * WebSocket接続完了イベント登録
+     * @param callback 接続時に呼ばれるコールバック
+     */
+    onConnect(callback: (uid: string) => void): void;
+    /**
+     * WebSocket再接続イベント登録
+     * @param callback 再接続試行時に呼ばれるコールバック
+     */
+    onReconnect(callback: (attemptCount: number) => void): void;
+    /**
+     * UID
+     */
+    get uid(): string | null;
+    /**
+     * クライアントインスタンスを取得
+     */
+    get client(): WebSocket;
+    /**
+     * 接続状態を取得
+     */
+    get isConnected(): boolean;
+    /**
+     * WebSocketエラーイベント登録
+     * @param callback エラー時に呼ばれるコールバック
+     */
+    onError(callback: (err: WebSocket.ErrorEvent) => void): void;
+    /**
+     * WebSocketクローズイベント登録
+     * @param callback クローズ時に呼ばれるコールバック
+     */
+    onClose(callback: (event: WebSocket.CloseEvent) => void): void;
+    /**
+     * チャネルサブスクメソッド
+     * @param channel チャネル名
+     * @param callback コールバック関数
+     */
+    on(channel: SymbolChannel, callback: (message: WebSocket.MessageEvent) => void): void;
+    /**
+     * チャネルサブスクメソッド
+     * @param channel チャネル名
+     * @param address アドレス
+     * @param callback コールバック関数
+     */
+    on(channel: SymbolChannel, address: string, callback: (message: WebSocket.MessageEvent) => void): void;
+    /**
+     * チャネルアンサブスクメソッド
+     * @param channel チャネル名
+     */
+    off(channel: SymbolChannel): void;
+    /**
+     * チャネルアンサブスクメソッド
+     * @param channel チャネル名
+     * @param address アドレス
+     */
+    off(channel: SymbolChannel, address: string): void;
+    /**
+     * WebSocket接続を切断
+     */
+    disconnect(): void;
+}
+
+export { type SymbolChannel, SymbolWebSocket, type SymbolWebSocketOptions, symbolChannelPaths };

package/dist/index.js

@@ -0,0 +1,246 @@
+// src/symbolChannelPaths.ts
+var symbolChannelPaths = {
+  block: { subscribe: () => "block" },
+  finalizedBlock: { subscribe: () => "finalizedBlock" },
+  confirmedAdded: { subscribe: (address) => address ? `confirmedAdded/${address}` : "confirmedAdded" },
+  unconfirmedAdded: { subscribe: (address) => address ? `unconfirmedAdded/${address}` : "unconfirmedAdded" },
+  unconfirmedRemoved: {
+    subscribe: (address) => address ? `unconfirmedRemoved/${address}` : "unconfirmedRemoved"
+  },
+  partialAdded: { subscribe: (address) => address ? `partialAdded/${address}` : "partialAdded" },
+  partialRemoved: { subscribe: (address) => address ? `partialRemoved/${address}` : "partialRemoved" },
+  cosignature: { subscribe: (address) => address ? `cosignature/${address}` : "cosignature" },
+  status: { subscribe: (address) => address ? `status/${address}` : "status" }
+};
+
+// src/SymbolWebSocket.ts
+import WebSocket from "isomorphic-ws";
+var WS_OPEN = WebSocket.OPEN ?? 1;
+var WS_CONNECTING = WebSocket.CONNECTING ?? 0;
+var SymbolWebSocket = class {
+  _client;
+  _uid = null;
+  isFirstMessage = true;
+  eventCallbacks = {};
+  pendingSubscribes = [];
+  errorCallbacks = [];
+  onCloseCallback = () => {
+  };
+  connectCallbacks = [];
+  reconnectCallbacks = [];
+  // 再接続関連のプロパティ
+  options;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  connectionTimeoutTimer = null;
+  isManualDisconnect = false;
+  activeSubscriptions = /* @__PURE__ */ new Set();
+  /**
+   * コンストラクタ
+   * @param options Symbolウェブソケットオプション
+   */
+  constructor(options) {
+    this.options = {
+      autoReconnect: true,
+      maxReconnectAttempts: Infinity,
+      reconnectInterval: 3e3,
+      ...options
+    };
+    this.createConnection();
+  }
+  /**
+   * WebSocket接続を作成
+   */
+  createConnection() {
+    const endPointHost = this.options.host;
+    const ssl = this.options.ssl ?? false;
+    const protocol = ssl ? "wss" : "ws";
+    const endPointPort = ssl ? "3001" : "3000";
+    this._client = new WebSocket(`${protocol}://${endPointHost}:${endPointPort}/ws`);
+    if (this.options.timeout) {
+      this.connectionTimeoutTimer = setTimeout(() => {
+        if (this._client.readyState === WS_CONNECTING || !this._uid) {
+          const timeoutError = new Error(`WebSocket connection timeout after ${this.options.timeout}ms`);
+          const errorEvent = { error: timeoutError, message: timeoutError.message };
+          this.errorCallbacks.forEach((cb) => cb(errorEvent));
+          this._client.close();
+        }
+      }, this.options.timeout);
+    }
+    this._client.onclose = (event) => {
+      this.onCloseCallback(event);
+      if (!this.isManualDisconnect && this.options.autoReconnect) {
+        this.attemptReconnect();
+      }
+    };
+    this._client.onerror = (err) => {
+      this.errorCallbacks.forEach((cb) => cb(err));
+    };
+    this._client.onmessage = (message) => {
+      try {
+        const data = JSON.parse(message.data.toString());
+        if (this.isFirstMessage) {
+          if (data.uid) {
+            this._uid = data.uid;
+            this.reconnectAttempts = 0;
+            if (this.connectionTimeoutTimer) {
+              clearTimeout(this.connectionTimeoutTimer);
+              this.connectionTimeoutTimer = null;
+            }
+            this.connectCallbacks.forEach((cb) => cb(this._uid));
+            this.activeSubscriptions.forEach((subscribePath) => {
+              this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+            });
+            this.pendingSubscribes.forEach(({ subscribePath }) => {
+              this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+              this.activeSubscriptions.add(subscribePath);
+            });
+            this.pendingSubscribes = [];
+          }
+          this.isFirstMessage = false;
+          return;
+        }
+        const channel = data.topic;
+        if (channel && this.eventCallbacks[channel]) {
+          this.eventCallbacks[channel].forEach((cb) => cb(data));
+        }
+      } catch (e) {
+        if (this.errorCallbacks.length > 0) {
+          const errorEvent = { ...e instanceof Error ? e : { message: String(e) } };
+          this.errorCallbacks.forEach((cb) => cb(errorEvent));
+        } else {
+          throw e;
+        }
+      }
+    };
+  }
+  /**
+   * 再接続を試みる
+   */
+  attemptReconnect() {
+    const maxAttempts = this.options.maxReconnectAttempts ?? Infinity;
+    if (this.reconnectAttempts >= maxAttempts) {
+      return;
+    }
+    this.reconnectAttempts++;
+    this.reconnectCallbacks.forEach((cb) => cb(this.reconnectAttempts));
+    const interval = this.options.reconnectInterval ?? 3e3;
+    this.reconnectTimer = setTimeout(() => {
+      this.isFirstMessage = true;
+      this._uid = null;
+      this.createConnection();
+    }, interval);
+  }
+  /**
+   * WebSocket接続完了イベント登録
+   * @param callback 接続時に呼ばれるコールバック
+   */
+  onConnect(callback) {
+    this.connectCallbacks.push(callback);
+    if (this._uid) {
+      callback(this._uid);
+    }
+  }
+  /**
+   * WebSocket再接続イベント登録
+   * @param callback 再接続試行時に呼ばれるコールバック
+   */
+  onReconnect(callback) {
+    this.reconnectCallbacks.push(callback);
+  }
+  /**
+   * UID
+   */
+  get uid() {
+    return this._uid;
+  }
+  /**
+   * クライアントインスタンスを取得
+   */
+  get client() {
+    return this._client;
+  }
+  /**
+   * 接続状態を取得
+   */
+  get isConnected() {
+    return this._client.readyState === WS_OPEN;
+  }
+  /**
+   * WebSocketエラーイベント登録
+   * @param callback エラー時に呼ばれるコールバック
+   */
+  onError(callback) {
+    this.errorCallbacks.push(callback);
+  }
+  /**
+   * WebSocketクローズイベント登録
+   * @param callback クローズ時に呼ばれるコールバック
+   */
+  onClose(callback) {
+    this.onCloseCallback = callback;
+  }
+  on(channel, addressOrCallback, callback) {
+    const address = typeof addressOrCallback === "string" ? addressOrCallback : void 0;
+    const actualCallback = typeof addressOrCallback === "function" ? addressOrCallback : callback;
+    const channelPath = symbolChannelPaths[channel];
+    const subscribePath = typeof channelPath.subscribe === "function" ? channelPath.subscribe(address) : channelPath.subscribe;
+    if (!subscribePath) {
+      throw new Error(`Subscribe path could not be determined for channel: ${channel}`);
+    }
+    if (!this.eventCallbacks[subscribePath]) {
+      this.eventCallbacks[subscribePath] = [];
+    }
+    this.eventCallbacks[subscribePath].push(actualCallback);
+    if (!this._uid) {
+      this.pendingSubscribes.push({ subscribePath, callback: actualCallback });
+      return;
+    }
+    if (this._client.readyState === WS_OPEN) {
+      this._client.send(JSON.stringify({ uid: this._uid, subscribe: subscribePath }));
+      this.activeSubscriptions.add(subscribePath);
+    }
+  }
+  off(channel, address) {
+    const channelPath = symbolChannelPaths[channel];
+    const subscribePath = typeof channelPath.subscribe === "function" ? channelPath.subscribe(address) : channelPath.subscribe;
+    if (!subscribePath) {
+      throw new Error(`Subscribe path could not be determined for channel: ${channel}`);
+    }
+    delete this.eventCallbacks[subscribePath];
+    this.activeSubscriptions.delete(subscribePath);
+    if (this._uid && this._client.readyState === WS_OPEN) {
+      this._client.send(JSON.stringify({ uid: this._uid, unsubscribe: subscribePath }));
+    }
+  }
+  /**
+   * WebSocket接続を切断
+   */
+  disconnect() {
+    this.isManualDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.connectionTimeoutTimer) {
+      clearTimeout(this.connectionTimeoutTimer);
+      this.connectionTimeoutTimer = null;
+    }
+    this.eventCallbacks = {};
+    this.pendingSubscribes = [];
+    this.errorCallbacks = [];
+    this.connectCallbacks = [];
+    this.reconnectCallbacks = [];
+    this.activeSubscriptions.clear();
+    if (this._client.readyState === WS_OPEN || this._client.readyState === WS_CONNECTING) {
+      this._client.close();
+    }
+    this._uid = null;
+    this.isFirstMessage = true;
+    this.reconnectAttempts = 0;
+  }
+};
+export {
+  SymbolWebSocket,
+  symbolChannelPaths
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@nemnesia/symbol-websocket",
+  "version": "0.1.0",
+  "description": "Symbol WebSocket Client Library",
+  "keywords": [
+    "nem",
+    "symbol",
+    "blockchain",
+    "websocket",
+    "nodejs"
+  ],
+  "author": "ccHarvestasya",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nemnesia/symbol-tools.git",
+    "directory": "packages/symbol-websocket"
+  },
+  "bugs": {
+    "url": "https://github.com/nemnesia/symbol-tools/issues"
+  },
+  "homepage": "https://github.com/nemnesia/symbol-tools/tree/main/packages/symbol-websocket#readme",
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@stomp/stompjs": "^7.2.1",
+    "isomorphic-ws": "^5.0.0",
+    "ws": "^8.18.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "volta": {
+    "node": "20.19.6"
+  },
+  "scripts": {
+    "build": "pnpm run clean && tsup",
+    "clean": "rm -rf dist",
+    "lint": "eslint \"{src,test,e2e}/**/*.ts\"",
+    "format": "prettier --write \"{src,test,e2e}/**/*.ts\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui --coverage",
+    "publish:dryrun": "npm publish --dry-run",
+    "publish:release": "npm run build && npm publish"
+  }
+}