@gbraver-burst-network/anonymous-browser-sdk 1.30.0-beta.0

package/lib/sdk/host-local-webrtc-sdk.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HostLocalWebRTCSDKImpl_webRTCConnection, _HostLocalWebRTCSDKImpl_websocketConnection, _HostLocalWebRTCSDKImpl_frontendLog;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHostLocalWebRTCSDK = createHostLocalWebRTCSDK;
+const nanoid_1 = require("nanoid");
+const create_room_1 = require("../websocket-api/create-room");
+const frontend_log_manager_1 = require("./frontend-log-manager");
+const host_webrtc_connection_manager_1 = require("./host-webrtc-connection-manager");
+const local_webrtc_room_1 = require("./local-webrtc-room");
+const websocket_connection_manager_1 = require("./websocket-connection-manager");
+/** ローカルWebRTCホスト用SDKの実装 */
+class HostLocalWebRTCSDKImpl {
+    /**
+     * コンストラクタ
+     * @param options コンストラクタのオプション
+     */
+    constructor(options) {
+        /** WebRTCコネクションマネージャー */
+        _HostLocalWebRTCSDKImpl_webRTCConnection.set(this, void 0);
+        /** WebSocketコネクションマネージャー */
+        _HostLocalWebRTCSDKImpl_websocketConnection.set(this, void 0);
+        /** フロントエンドログマネージャー */
+        _HostLocalWebRTCSDKImpl_frontendLog.set(this, void 0);
+        __classPrivateFieldSet(this, _HostLocalWebRTCSDKImpl_websocketConnection, new websocket_connection_manager_1.WebSocketConnectionManager(options), "f");
+        __classPrivateFieldSet(this, _HostLocalWebRTCSDKImpl_webRTCConnection, new host_webrtc_connection_manager_1.HostWebRTCConnectionManager(options), "f");
+        __classPrivateFieldSet(this, _HostLocalWebRTCSDKImpl_frontendLog, new frontend_log_manager_1.FrontendLogManager(options), "f");
+    }
+    /** @override */
+    createRoom(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const spanId = (0, nanoid_1.nanoid)();
+            try {
+                __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").gracefulDisconnect();
+                __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_webRTCConnection, "f").disconnect();
+                const websocket = yield __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").getOrCreate();
+                const roomID = yield (0, create_room_1.createRoom)(websocket);
+                if (roomID === null) {
+                    __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").gracefulDisconnect();
+                    return null;
+                }
+                const { armdozerId: hostArmdozerId, pilotId: hostPilotId } = options;
+                return new local_webrtc_room_1.LocalWebRTCRoomImpl({
+                    roomID,
+                    spanId,
+                    webRTCConnection: __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_webRTCConnection, "f"),
+                    websocketConnection: __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f"),
+                    frontendLog: __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_frontendLog, "f"),
+                    hostArmdozerId,
+                    hostPilotId,
+                });
+            }
+            catch (e) {
+                __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").gracefulDisconnect();
+                throw e;
+            }
+        });
+    }
+    /** @override */
+    websocketErrorNotifier() {
+        return __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").errorNotifier();
+    }
+    /** @override */
+    disconnectWebSocket() {
+        __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_websocketConnection, "f").gracefulDisconnect();
+    }
+    /** @override */
+    disconnectWebRTC() {
+        __classPrivateFieldGet(this, _HostLocalWebRTCSDKImpl_webRTCConnection, "f").disconnect();
+    }
+}
+_HostLocalWebRTCSDKImpl_webRTCConnection = new WeakMap(), _HostLocalWebRTCSDKImpl_websocketConnection = new WeakMap(), _HostLocalWebRTCSDKImpl_frontendLog = new WeakMap();
+/**
+ * ローカルWebRTCホスト用SDKを生成する
+ * @param options SDK生成のオプション
+ * @returns ローカルWebRTCホスト用SDKのインスタンス
+ */
+function createHostLocalWebRTCSDK(options) {
+    return new HostLocalWebRTCSDKImpl(options);
+}

package/lib/sdk/host-webrtc-connection-manager.d.ts

@@ -0,0 +1,37 @@
+import { AuthTokenManager } from "./auth-token-manager";
+/** コネクション情報 */
+type Connection = {
+    /** WebRTCコネクション */
+    connection: RTCPeerConnection;
+    /** データチャンネル */
+    dataChannel: RTCDataChannel;
+};
+/** HostWebRTCConnectionManagerコンストラクタのオプション */
+export type HostWebRTCConnectionManagerOptions = {
+    /** 認証トークンマネージャー */
+    authToken: AuthTokenManager;
+    /** WebRTCヘルパーAPIのURL */
+    webRTCHelperApiURL: string;
+    /** coturnサーバーのドメイン名 */
+    coturnDomainName: string;
+};
+/** ホストのWebRTCコネクション管理 */
+export declare class HostWebRTCConnectionManager {
+    #private;
+    /**
+     * コンストラクタ
+     * @param options オプション
+     */
+    constructor(options: HostWebRTCConnectionManagerOptions);
+    /**
+     * コネクションを取得する。
+     * コネクションが存在しない場合は新たに作成する。
+     * @returns 生成したコネクション
+     */
+    getOrCreateConnection(): Promise<Connection>;
+    /**
+     * コネクションを切断する
+     */
+    disconnect(): void;
+}
+export {};

package/lib/sdk/host-webrtc-connection-manager.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _HostWebRTCConnectionManager_authToken, _HostWebRTCConnectionManager_connection, _HostWebRTCConnectionManager_webRTCHelperApiURL, _HostWebRTCConnectionManager_coturnDomainName;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostWebRTCConnectionManager = void 0;
+const create_rtc_peer_connection_1 = require("./create-rtc-peer-connection");
+/** ホストのWebRTCコネクション管理 */
+class HostWebRTCConnectionManager {
+    /**
+     * コンストラクタ
+     * @param options オプション
+     */
+    constructor(options) {
+        /** 認証トークンマネージャー */
+        _HostWebRTCConnectionManager_authToken.set(this, void 0);
+        /** コネクション情報、nullで未接続 */
+        _HostWebRTCConnectionManager_connection.set(this, null);
+        /** WebRTCヘルパーAPIのURL */
+        _HostWebRTCConnectionManager_webRTCHelperApiURL.set(this, void 0);
+        /** coturnサーバーのドメイン名 */
+        _HostWebRTCConnectionManager_coturnDomainName.set(this, void 0);
+        __classPrivateFieldSet(this, _HostWebRTCConnectionManager_authToken, options.authToken, "f");
+        __classPrivateFieldSet(this, _HostWebRTCConnectionManager_webRTCHelperApiURL, options.webRTCHelperApiURL, "f");
+        __classPrivateFieldSet(this, _HostWebRTCConnectionManager_coturnDomainName, options.coturnDomainName, "f");
+    }
+    /**
+     * コネクションを取得する。
+     * コネクションが存在しない場合は新たに作成する。
+     * @returns 生成したコネクション
+     */
+    getOrCreateConnection() {
+        if (__classPrivateFieldGet(this, _HostWebRTCConnectionManager_connection, "f")) {
+            return __classPrivateFieldGet(this, _HostWebRTCConnectionManager_connection, "f");
+        }
+        __classPrivateFieldSet(this, _HostWebRTCConnectionManager_connection, (() => __awaiter(this, void 0, void 0, function* () {
+            const authToken = yield __classPrivateFieldGet(this, _HostWebRTCConnectionManager_authToken, "f").getOrIssueAuthToken();
+            const connection = yield (0, create_rtc_peer_connection_1.createRTCPeerConnection)({
+                webRTCHelperApiURL: __classPrivateFieldGet(this, _HostWebRTCConnectionManager_webRTCHelperApiURL, "f"),
+                coturnDomainName: __classPrivateFieldGet(this, _HostWebRTCConnectionManager_coturnDomainName, "f"),
+                authToken: authToken.token,
+            });
+            const dataChannel = connection.createDataChannel("sendDataChannel");
+            return { connection, dataChannel };
+        }))().catch((err) => {
+            __classPrivateFieldSet(this, _HostWebRTCConnectionManager_connection, null, "f");
+            throw err;
+        }), "f");
+        return __classPrivateFieldGet(this, _HostWebRTCConnectionManager_connection, "f");
+    }
+    /**
+     * コネクションを切断する
+     */
+    disconnect() {
+        if (!__classPrivateFieldGet(this, _HostWebRTCConnectionManager_connection, "f")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _HostWebRTCConnectionManager_connection, "f").then(({ connection, dataChannel }) => {
+            connection.close();
+            dataChannel.close();
+        });
+        __classPrivateFieldSet(this, _HostWebRTCConnectionManager_connection, null, "f");
+    }
+}
+exports.HostWebRTCConnectionManager = HostWebRTCConnectionManager;
+_HostWebRTCConnectionManager_authToken = new WeakMap(), _HostWebRTCConnectionManager_connection = new WeakMap(), _HostWebRTCConnectionManager_webRTCHelperApiURL = new WeakMap(), _HostWebRTCConnectionManager_coturnDomainName = new WeakMap();

package/lib/sdk/local-webrtc-room.d.ts

@@ -0,0 +1,44 @@
+import { ArmdozerId, PilotId } from "gbraver-burst-core";
+import { BattleSDK } from "./battle-sdk";
+import { FrontendLogManager } from "./frontend-log-manager";
+import { HostWebRTCConnectionManager } from "./host-webrtc-connection-manager";
+import { WebSocketConnectionManager } from "./websocket-connection-manager";
+/** ローカルWebRTC ルーム */
+export type LocalWebRTCRoom = {
+    /** ルームID */
+    readonly roomID: string;
+    /**
+     * マッチングするまで待機する
+     * @returns マッチングした相手とのバトルSDK
+     */
+    waitUntilMatching: () => Promise<BattleSDK>;
+};
+/** ローカルWebRTCルームの実装 */
+export declare class LocalWebRTCRoomImpl implements LocalWebRTCRoom {
+    #private;
+    /** ルームID */
+    roomID: string;
+    /**
+     * コンストラクタ
+     * @param options ルームの生成に必要なオプション
+     * @param options.spanId ログ用の識別子
+     * @param options.roomID ルームID
+     * @param options.webRTCConnection WebRTCコネクションマネジャー
+     * @param options.websocketConnection WebSocketコネクションマネジャー
+     * @param options.frontendLog フロントエンドログマネジャー
+     */
+    constructor(options: {
+        roomID: string;
+        spanId: string;
+        webRTCConnection: HostWebRTCConnectionManager;
+        websocketConnection: WebSocketConnectionManager;
+        frontendLog: FrontendLogManager;
+        hostArmdozerId: ArmdozerId;
+        hostPilotId: PilotId;
+    });
+    /**
+     * マッチングするまで待機する
+     * @returns マッチングしたら発火するPromise
+     */
+    waitUntilMatching(): Promise<BattleSDK>;
+}

package/lib/sdk/local-webrtc-room.js

@@ -0,0 +1,178 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LocalWebRTCRoomImpl_instances, _LocalWebRTCRoomImpl_spanId, _LocalWebRTCRoomImpl_webRTCConnection, _LocalWebRTCRoomImpl_websocketConnection, _LocalWebRTCRoomImpl_frontendLog, _LocalWebRTCRoomImpl_hostArmdozerId, _LocalWebRTCRoomImpl_hostPilotId, _LocalWebRTCRoomImpl_signaling;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalWebRTCRoomImpl = void 0;
+const nanoid_1 = require("nanoid");
+const rxjs_1 = require("rxjs");
+const gather_all_ice_candidate_1 = require("../webrtc/gather-all-ice-candidate");
+const get_selected_ice_candidate_summary_1 = require("../webrtc/get-selected-ice-candidate-summary");
+const host_message_1 = require("../webrtc/host/host-message");
+const request_selected_player_1 = require("../webrtc/host/request-selected-player");
+const wait_until_connected_1 = require("../webrtc/wait-until-connected");
+const wait_until_data_channel_ready_1 = require("../webrtc/wait-until-data-channel-ready");
+const delete_signaling_channel_1 = require("../websocket-api/delete-signaling-channel");
+const notify_ice_candidate_recieved_1 = require("../websocket-api/notify-ice-candidate-recieved");
+const send_to_ws_signal_1 = require("../websocket-api/send-to-ws-signal");
+const wait_until_matching_1 = require("../websocket-api/wait-until-matching");
+const wait_until_sdp_recieve_1 = require("../websocket-api/wait-until-sdp-recieve");
+const host_battle_sdk_1 = require("./host-battle-sdk");
+/** ローカルWebRTCルームの実装 */
+class LocalWebRTCRoomImpl {
+    /**
+     * コンストラクタ
+     * @param options ルームの生成に必要なオプション
+     * @param options.spanId ログ用の識別子
+     * @param options.roomID ルームID
+     * @param options.webRTCConnection WebRTCコネクションマネジャー
+     * @param options.websocketConnection WebSocketコネクションマネジャー
+     * @param options.frontendLog フロントエンドログマネジャー
+     */
+    constructor(options) {
+        _LocalWebRTCRoomImpl_instances.add(this);
+        /** ログ用の識別子 */
+        _LocalWebRTCRoomImpl_spanId.set(this, void 0);
+        /** WebRTCコネクションマネージャー */
+        _LocalWebRTCRoomImpl_webRTCConnection.set(this, void 0);
+        /** WebSocketコネクションマネージャー */
+        _LocalWebRTCRoomImpl_websocketConnection.set(this, void 0);
+        /** フロントエンドログマネージャー */
+        _LocalWebRTCRoomImpl_frontendLog.set(this, void 0);
+        /** ホストが選択したアームドーザID */
+        _LocalWebRTCRoomImpl_hostArmdozerId.set(this, void 0);
+        /** ホストが選択したパイロットID */
+        _LocalWebRTCRoomImpl_hostPilotId.set(this, void 0);
+        const { roomID, spanId, webRTCConnection, websocketConnection, hostArmdozerId, hostPilotId, frontendLog, } = options;
+        this.roomID = roomID;
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_spanId, spanId, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_webRTCConnection, webRTCConnection, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_websocketConnection, websocketConnection, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_hostArmdozerId, hostArmdozerId, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_hostPilotId, hostPilotId, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_frontendLog, frontendLog, "f");
+    }
+    /**
+     * マッチングするまで待機する
+     * @returns マッチングしたら発火するPromise
+     */
+    waitUntilMatching() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_instances, "m", _LocalWebRTCRoomImpl_signaling).call(this);
+            const { dataChannel } = yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_webRTCConnection, "f").getOrCreateConnection();
+            const flowID = (0, nanoid_1.nanoid)();
+            const { armdozerId: guestArmdozerId, pilotId: guestPilotId } = yield (0, request_selected_player_1.requestSelectedPlayer)(dataChannel, flowID);
+            const battleSDK = new host_battle_sdk_1.HostBattleSDK({
+                hostArmdozerId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_hostArmdozerId, "f"),
+                hostPilotId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_hostPilotId, "f"),
+                guestArmdozerId,
+                guestPilotId,
+                webRTCConnection: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_webRTCConnection, "f"),
+            });
+            (0, host_message_1.sendHostMessage)(dataChannel, {
+                type: "battle-start",
+                flowID: battleSDK.flowID,
+                hostPlayer: battleSDK.player,
+                guestPlayer: battleSDK.enemy,
+                update: battleSDK.initialState,
+            });
+            return battleSDK;
+        });
+    }
+}
+exports.LocalWebRTCRoomImpl = LocalWebRTCRoomImpl;
+_LocalWebRTCRoomImpl_spanId = new WeakMap(), _LocalWebRTCRoomImpl_webRTCConnection = new WeakMap(), _LocalWebRTCRoomImpl_websocketConnection = new WeakMap(), _LocalWebRTCRoomImpl_frontendLog = new WeakMap(), _LocalWebRTCRoomImpl_hostArmdozerId = new WeakMap(), _LocalWebRTCRoomImpl_hostPilotId = new WeakMap(), _LocalWebRTCRoomImpl_instances = new WeakSet(), _LocalWebRTCRoomImpl_signaling = function _LocalWebRTCRoomImpl_signaling() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let unSubscribers = [];
+        try {
+            yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_frontendLog, "f").log({
+                type: "SIGNALING_START",
+                spanId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_spanId, "f"),
+            });
+            const websocket = yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_websocketConnection, "f").getOrCreate();
+            const signalingID = yield (0, wait_until_matching_1.waitUntilMatching)(websocket);
+            const { connection, dataChannel } = yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_webRTCConnection, "f").getOrCreateConnection();
+            let isRemoteDescriptionSet = false;
+            const pendingIceCandidates = [];
+            // イベントを取り逃がさないように、あらかじめハンドラをセットしておく
+            unSubscribers = [
+                (0, notify_ice_candidate_recieved_1.notifyIceCandidateReceived)(websocket).subscribe((iceCandidate) => {
+                    if (isRemoteDescriptionSet) {
+                        connection.addIceCandidate(iceCandidate);
+                    }
+                    else {
+                        pendingIceCandidates.push(iceCandidate);
+                    }
+                }),
+                (0, rxjs_1.fromEvent)(connection, "icecandidate").subscribe((event) => {
+                    if (event.candidate) {
+                        (0, send_to_ws_signal_1.sendToWSSignal)(websocket, {
+                            action: "send-ice-candidate",
+                            signalingID,
+                            iceCandidate: event.candidate,
+                        });
+                    }
+                }),
+                (0, rxjs_1.fromEvent)(connection, "icecandidateerror").subscribe((event) => {
+                    __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_frontendLog, "f").log({
+                        type: "ICE_CANDIDATE_ERROR",
+                        spanId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_spanId, "f"),
+                        error: (0, gather_all_ice_candidate_1.createICECandidateErrorMessage)(event),
+                    });
+                }),
+            ];
+            const sdp = yield connection.createOffer();
+            yield connection.setLocalDescription(sdp);
+            (0, send_to_ws_signal_1.sendToWSSignal)(websocket, {
+                action: "send-sdp",
+                signalingID,
+                sdp,
+            });
+            const remoteSDP = yield (0, wait_until_sdp_recieve_1.waitUntilSDPReceive)(websocket);
+            yield connection.setRemoteDescription(remoteSDP);
+            isRemoteDescriptionSet = true;
+            pendingIceCandidates.forEach((iceCandidate) => {
+                connection.addIceCandidate(iceCandidate);
+            });
+            yield Promise.all([
+                (0, wait_until_connected_1.waitUntilConnected)(connection),
+                (0, wait_until_data_channel_ready_1.waitUntilDataChannelOpen)(dataChannel),
+            ]);
+            yield (0, delete_signaling_channel_1.deleteSignalingChannel)({ websocket, signalingID });
+            yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_frontendLog, "f").log({
+                type: "SIGNALING_END",
+                spanId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_spanId, "f"),
+            });
+            const selectedLocalIceCandidateSummary = yield (0, get_selected_ice_candidate_summary_1.getSelectedIceCandidateSummary)(connection);
+            if (selectedLocalIceCandidateSummary !== null) {
+                yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_frontendLog, "f").log({
+                    type: "SELECTED_ICE_CANDIDATE_SUMMARY",
+                    spanId: __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_spanId, "f"),
+                    summary: selectedLocalIceCandidateSummary,
+                });
+            }
+        }
+        finally {
+            unSubscribers.forEach((u) => u.unsubscribe());
+            __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_websocketConnection, "f").gracefulDisconnect();
+        }
+    });
+};

package/lib/sdk/websocket-connection-manager.d.ts

@@ -0,0 +1,34 @@
+import { Observable } from "rxjs";
+import { AuthTokenManager } from "./auth-token-manager";
+/** WebSocketコネクション管理 */
+export declare class WebSocketConnectionManager {
+    #private;
+    /** WebSocketシグナルサーバーのURL */
+    readonly wsSignalUrl: string;
+    /**
+     * コンストラクタ
+     * @param options オプション
+     * @param options.wsSignalUrl WebSocketシグナルサーバーのURL
+     * @param options.authToken 認証トークンマネージャー
+     */
+    constructor(options: {
+        wsSignalUrl: string;
+        authToken: AuthTokenManager;
+    });
+    /**
+     * WebSocketクライアントの取得を行う
+     * WebSocketクライアントが存在しない場合は、本メソッド内で生成してから返す
+     * @returns 取得、生成結果
+     */
+    getOrCreate(): Promise<WebSocket>;
+    /**
+     * Websocketコネクションを切断する
+     * 本メソッドを呼び出すことで、WebSocketコネクションに関連するイベントストリームの購読も解除する
+     */
+    gracefulDisconnect(): void;
+    /**
+     * WebSocketのエラーを通知する
+     * @returns 通知ストリーム
+     */
+    errorNotifier(): Observable<unknown>;
+}

package/lib/sdk/websocket-connection-manager.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WebSocketConnectionManager_authToken, _WebSocketConnectionManager_websocketError, _WebSocketConnectionManager_connection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnectionManager = void 0;
+const rxjs_1 = require("rxjs");
+const connect_ws_signal_1 = require("../websocket-api/connect-ws-signal");
+/** WebSocketコネクション管理 */
+class WebSocketConnectionManager {
+    /**
+     * コンストラクタ
+     * @param options オプション
+     * @param options.wsSignalUrl WebSocketシグナルサーバーのURL
+     * @param options.authToken 認証トークンマネージャー
+     */
+    constructor(options) {
+        /** 認証トークンマネージャー */
+        _WebSocketConnectionManager_authToken.set(this, void 0);
+        /** Web Socket エラー通知 */
+        _WebSocketConnectionManager_websocketError.set(this, void 0);
+        /** コネクション情報、nullで未接続 */
+        _WebSocketConnectionManager_connection.set(this, null);
+        this.wsSignalUrl = options.wsSignalUrl;
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_authToken, options.authToken, "f");
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_websocketError, new rxjs_1.Subject(), "f");
+    }
+    /**
+     * WebSocketクライアントの取得を行う
+     * WebSocketクライアントが存在しない場合は、本メソッド内で生成してから返す
+     * @returns 取得、生成結果
+     */
+    getOrCreate() {
+        if (__classPrivateFieldGet(this, _WebSocketConnectionManager_connection, "f")) {
+            return __classPrivateFieldGet(this, _WebSocketConnectionManager_connection, "f").then((v) => v.websocket);
+        }
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_connection, (() => __awaiter(this, void 0, void 0, function* () {
+            const authToken = yield __classPrivateFieldGet(this, _WebSocketConnectionManager_authToken, "f").getOrIssueAuthToken();
+            const websocket = yield (0, connect_ws_signal_1.connectWSSignal)(this.wsSignalUrl, authToken.token);
+            const websocketSubscriptions = [
+                (0, rxjs_1.fromEvent)(websocket, "error").subscribe(__classPrivateFieldGet(this, _WebSocketConnectionManager_websocketError, "f")),
+                (0, rxjs_1.fromEvent)(websocket, "close").subscribe(__classPrivateFieldGet(this, _WebSocketConnectionManager_websocketError, "f")),
+            ];
+            return { websocket, websocketSubscriptions };
+        }))().catch((err) => {
+            __classPrivateFieldSet(this, _WebSocketConnectionManager_connection, null, "f");
+            throw err;
+        }), "f");
+        return __classPrivateFieldGet(this, _WebSocketConnectionManager_connection, "f").then((v) => v.websocket);
+    }
+    /**
+     * Websocketコネクションを切断する
+     * 本メソッドを呼び出すことで、WebSocketコネクションに関連するイベントストリームの購読も解除する
+     */
+    gracefulDisconnect() {
+        if (!__classPrivateFieldGet(this, _WebSocketConnectionManager_connection, "f")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _WebSocketConnectionManager_connection, "f").then((v) => {
+            v.websocket.close();
+            v.websocketSubscriptions.forEach((s) => s.unsubscribe());
+        });
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_connection, null, "f");
+    }
+    /**
+     * WebSocketのエラーを通知する
+     * @returns 通知ストリーム
+     */
+    errorNotifier() {
+        return __classPrivateFieldGet(this, _WebSocketConnectionManager_websocketError, "f");
+    }
+}
+exports.WebSocketConnectionManager = WebSocketConnectionManager;
+_WebSocketConnectionManager_authToken = new WeakMap(), _WebSocketConnectionManager_websocketError = new WeakMap(), _WebSocketConnectionManager_connection = new WeakMap();

package/lib/webrtc/gather-all-ice-candidate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ICE Candidateの収集中に発生したエラーのメッセージを作成する
+ * @param error ICE Candidateの収集中に発生したエラー
+ * @returns エラーメッセージ
+ */
+export declare const createICECandidateErrorMessage: (error: RTCPeerConnectionIceErrorEvent) => string;
+/** ICE Candidateの収集結果 */
+type Result = {
+    /** 収集したICE Candidate */
+    iceCandidates: RTCIceCandidate[];
+    /** 発生したICE Candidateのエラー */
+    iceCandidateErrors: string[];
+};
+/**
+ * すべてのICE Candidateが収集する
+ * @param connection 待機するコネクション
+ * @returns 収集結果
+ */
+export declare const gatherAllIceCandidates: (connection: RTCPeerConnection) => Promise<Result>;
+export {};

package/lib/webrtc/gather-all-ice-candidate.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherAllIceCandidates = exports.createICECandidateErrorMessage = void 0;
+/**
+ * ICE Candidateの収集中に発生したエラーのメッセージを作成する
+ * @param error ICE Candidateの収集中に発生したエラー
+ * @returns エラーメッセージ
+ */
+const createICECandidateErrorMessage = (error) => `${error.errorCode} ${error.url} ${error.errorText}`;
+exports.createICECandidateErrorMessage = createICECandidateErrorMessage;
+/**
+ * すべてのICE Candidateが収集する
+ * @param connection 待機するコネクション
+ * @returns 収集結果
+ */
+const gatherAllIceCandidates = (connection) => {
+    let icecandidateHandler = null;
+    let icecandidateErrorHandler = null;
+    let candidates = [];
+    let iceCandidateErrors = [];
+    return new Promise((resolve) => {
+        icecandidateHandler = (event) => {
+            if (event.candidate === null) {
+                resolve({ iceCandidates: candidates, iceCandidateErrors });
+            }
+            else {
+                candidates = [...candidates, event.candidate];
+            }
+        };
+        icecandidateErrorHandler = (event) => {
+            const errorMessage = (0, exports.createICECandidateErrorMessage)(event);
+            iceCandidateErrors = [...iceCandidateErrors, errorMessage];
+        };
+        connection.addEventListener("icecandidate", icecandidateHandler);
+        connection.addEventListener("icecandidateerror", icecandidateErrorHandler);
+    }).finally(() => {
+        if (icecandidateHandler) {
+            connection.removeEventListener("icecandidate", icecandidateHandler);
+        }
+        if (icecandidateErrorHandler) {
+            connection.removeEventListener("icecandidateerror", icecandidateErrorHandler);
+        }
+    });
+};
+exports.gatherAllIceCandidates = gatherAllIceCandidates;

package/lib/webrtc/get-selected-ice-candidate-summary.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 経路として選択されたローカル ICE Candidate の概要を取得する
+ * @param connection WebRTCコネクション
+ * @returns 経路として選択されたローカル ICE Candidate の概要文字列、存在しない場合は null
+ */
+export declare const getSelectedIceCandidateSummary: (connection: RTCPeerConnection) => Promise<string | null>;