@gbraver-burst-network/local-webrtc-browser-sdk 1.20.0-beta.0

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

@@ -0,0 +1,136 @@
+"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 _LocalWebRTCGuestSDKImpl_instances, _LocalWebRTCGuestSDKImpl_webRTCConnection, _LocalWebRTCGuestSDKImpl_websocketConnection, _LocalWebRTCGuestSDKImpl_signaling;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalWebRTCGuestSDK = createLocalWebRTCGuestSDK;
+const guest_message_1 = require("../webrtc/guest/guest-message");
+const receive_battle_start_1 = require("../webrtc/guest/receive-battle-start");
+const receive_request_selected_player_1 = require("../webrtc/guest/receive-request-selected-player");
+const wait_until_connected_1 = require("../webrtc/wait-until-connected");
+const wait_untilIce_candidate_1 = require("../webrtc/wait-untilIce-candidate");
+const join_room_1 = require("../ws-signal/join-room");
+const send_guest_signal_1 = require("../ws-signal/send-guest-signal");
+const guest_battle_sdk_1 = require("./guest-battle-sdk");
+const guest_webrtc_connection_manager_1 = require("./guest-webrtc-connection-manager");
+const websocket_connection_manager_1 = require("./websocket-connection-manager");
+/** ローカルWebRTCゲスト用SDKの実装 */
+class LocalWebRTCGuestSDKImpl {
+    /**
+     * コンストラクタ
+     * @param wsSignalUrl WebSocketシグナルサーバーのURL
+     */
+    constructor(wsSignalUrl) {
+        _LocalWebRTCGuestSDKImpl_instances.add(this);
+        /** WebRTCコネクションマネージャー */
+        _LocalWebRTCGuestSDKImpl_webRTCConnection.set(this, void 0);
+        /** WebSocketコネクションマネージャー */
+        _LocalWebRTCGuestSDKImpl_websocketConnection.set(this, void 0);
+        __classPrivateFieldSet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, new guest_webrtc_connection_manager_1.GuestWebRTCConnectionManager(), "f");
+        __classPrivateFieldSet(this, _LocalWebRTCGuestSDKImpl_websocketConnection, new websocket_connection_manager_1.WebSocketConnectionManager(wsSignalUrl), "f");
+    }
+    /** @override */
+    joinRoom(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { roomID, armdozerId, pilotId } = options;
+            const requestSelectedPlayerPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                const dataChannel = yield __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f").getOrCreateConnection().dataChannel;
+                return yield (0, receive_request_selected_player_1.receiveRequestSelectedPlayer)(dataChannel);
+            }))();
+            const battleStartPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                const dataChannel = yield __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f").getOrCreateConnection().dataChannel;
+                return yield (0, receive_battle_start_1.receiveBattleStart)(dataChannel);
+            }))();
+            const isSignalingSuccessful = yield __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_instances, "m", _LocalWebRTCGuestSDKImpl_signaling).call(this, roomID);
+            if (!isSignalingSuccessful) {
+                return null;
+            }
+            const { flowID } = yield requestSelectedPlayerPromise;
+            const dataChannel = yield __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f").getOrCreateConnection().dataChannel;
+            (0, guest_message_1.sendGuestMessage)(dataChannel, {
+                type: "send-player",
+                flowID,
+                armdozerId,
+                pilotId,
+            });
+            const battleStart = yield battleStartPromise;
+            return new guest_battle_sdk_1.GuestBattleSDK({
+                hostPlayer: battleStart.hostPlayer,
+                guestPlayer: battleStart.guestPlayer,
+                initialState: battleStart.update,
+                initialFlowID: battleStart.flowID,
+                webRTCConnection: __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f"),
+            });
+        });
+    }
+    /** @override */
+    websocketErrorNotifier() {
+        return __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_websocketConnection, "f").errorNotifier();
+    }
+    /** @override */
+    disconnectWebRTC() {
+        __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f").disconnect();
+    }
+}
+_LocalWebRTCGuestSDKImpl_webRTCConnection = new WeakMap(), _LocalWebRTCGuestSDKImpl_websocketConnection = new WeakMap(), _LocalWebRTCGuestSDKImpl_instances = new WeakSet(), _LocalWebRTCGuestSDKImpl_signaling = function _LocalWebRTCGuestSDKImpl_signaling(roomID) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const websocket = yield __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_websocketConnection, "f").getOrCreate();
+            const joinRoomAccepted = yield (0, join_room_1.joinRoom)({ websocket, roomID });
+            if (!joinRoomAccepted) {
+                return false;
+            }
+            const { sdp: hostSDP, iceCandidates: hostIceCandidates } = joinRoomAccepted;
+            const { connection } = __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_webRTCConnection, "f").getOrCreateConnection();
+            yield connection.setRemoteDescription(hostSDP);
+            yield Promise.all(hostIceCandidates.map((c) => connection.addIceCandidate(c)));
+            const guestSDP = yield connection.createAnswer();
+            const [guestIceCandidates] = yield Promise.all([
+                // icecandidateイベントはsetLocalDescriptionの後に発生するため、先に待機しておく
+                (0, wait_untilIce_candidate_1.waitUntilIceCandidate)(connection),
+                connection.setLocalDescription(guestSDP),
+            ]);
+            const { reservationID } = joinRoomAccepted;
+            yield Promise.all([
+                (0, send_guest_signal_1.sendGuestSignal)({
+                    websocket,
+                    roomID,
+                    reservationID,
+                    sdp: guestSDP,
+                    iceCandidates: guestIceCandidates,
+                }),
+                (0, wait_until_connected_1.waitUntilConnected)(connection),
+            ]);
+            return true;
+        }
+        finally {
+            __classPrivateFieldGet(this, _LocalWebRTCGuestSDKImpl_websocketConnection, "f").gracefulDisconnect();
+        }
+    });
+};
+/**
+ * ローカルWebRTCゲスト用SDKを生成する
+ * @param wsSignalUrl WebSocketシグナルサーバーのURL
+ * @returns ローカルWebRTCゲスト用SDKのインスタンス
+ */
+function createLocalWebRTCGuestSDK(wsSignalUrl) {
+    return new LocalWebRTCGuestSDKImpl(wsSignalUrl);
+}

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

@@ -0,0 +1,32 @@
+import { ArmdozerId, PilotId } from "gbraver-burst-core";
+import { Observable } from "rxjs";
+import { LocalWebRTCRoom } from "./local-webrtc-room";
+/** ローカルWebRTCホスト用SDK */
+export type LocalWebRTCHostSDK = {
+    /**
+     * ルームを生成する
+     * @param options ルーム生成のオプション
+     * @param options.armdozerId ホストが選択したアームドーザのID
+     * @param options.pilotId ホストが選択したパイロットのID
+     * @returns 生成されたルーム、生成に失敗した場合はnull
+     */
+    createRoom: (options: {
+        armdozerId: ArmdozerId;
+        pilotId: PilotId;
+    }) => Promise<LocalWebRTCRoom | null>;
+    /**
+     * WebSocketのエラーを通知する
+     * @returns 通知ストリーム
+     */
+    websocketErrorNotifier(): Observable<unknown>;
+    /**
+     * WebRTCコネクションを切断する
+     */
+    disconnectWebRTC(): void;
+};
+/**
+ * ローカルWebRTCホスト用SDKを生成する
+ * @param wsSignalUrl WebSocketシグナルサーバーのURL
+ * @returns ローカルWebRTCホスト用SDKのインスタンス
+ */
+export declare function createLocalWebRTCHostSDK(wsSignalUrl: string): LocalWebRTCHostSDK;

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

@@ -0,0 +1,93 @@
+"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 _LocalWebRTCHostSDKImpl_webRTCConnection, _LocalWebRTCHostSDKImpl_websocketConnection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalWebRTCHostSDK = createLocalWebRTCHostSDK;
+const wait_untilIce_candidate_1 = require("../webrtc/wait-untilIce-candidate");
+const create_room_1 = require("../ws-signal/create-room");
+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 LocalWebRTCHostSDKImpl {
+    /**
+     * コンストラクタ
+     * @param wsSignalUrl WebSocketシグナルサーバーのURL
+     */
+    constructor(wsSignalUrl) {
+        /** WebRTCコネクションマネージャー */
+        _LocalWebRTCHostSDKImpl_webRTCConnection.set(this, void 0);
+        /** WebSocketコネクションマネージャー */
+        _LocalWebRTCHostSDKImpl_websocketConnection.set(this, void 0);
+        __classPrivateFieldSet(this, _LocalWebRTCHostSDKImpl_websocketConnection, new websocket_connection_manager_1.WebSocketConnectionManager(wsSignalUrl), "f");
+        __classPrivateFieldSet(this, _LocalWebRTCHostSDKImpl_webRTCConnection, new host_webrtc_connection_manager_1.HostWebRTCConnectionManager(), "f");
+    }
+    /** @override */
+    createRoom(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { connection } = __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_webRTCConnection, "f").getOrCreateConnection();
+                const sdp = yield connection.createOffer();
+                const [iceCandidates] = yield Promise.all([
+                    // icecandidateイベントはsetLocalDescriptionの後に発生するため、先に待機しておく
+                    (0, wait_untilIce_candidate_1.waitUntilIceCandidate)(connection),
+                    connection.setLocalDescription(sdp),
+                ]);
+                const websocket = yield __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_websocketConnection, "f").getOrCreate();
+                const roomID = yield (0, create_room_1.createRoom)({ websocket, sdp, iceCandidates });
+                if (roomID === null) {
+                    __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_websocketConnection, "f").gracefulDisconnect();
+                    return null;
+                }
+                const { armdozerId: hostArmdozerId, pilotId: hostPilotId } = options;
+                return new local_webrtc_room_1.LocalWebRTCRoomImpl({
+                    roomID,
+                    webRTCConnection: __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_webRTCConnection, "f"),
+                    websocketConnection: __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_websocketConnection, "f"),
+                    hostArmdozerId,
+                    hostPilotId,
+                });
+            }
+            catch (e) {
+                __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_websocketConnection, "f").gracefulDisconnect();
+                throw e;
+            }
+        });
+    }
+    /** @override */
+    websocketErrorNotifier() {
+        return __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_websocketConnection, "f").errorNotifier();
+    }
+    /** @override */
+    disconnectWebRTC() {
+        __classPrivateFieldGet(this, _LocalWebRTCHostSDKImpl_webRTCConnection, "f").disconnect();
+    }
+}
+_LocalWebRTCHostSDKImpl_webRTCConnection = new WeakMap(), _LocalWebRTCHostSDKImpl_websocketConnection = new WeakMap();
+/**
+ * ローカルWebRTCホスト用SDKを生成する
+ * @param wsSignalUrl WebSocketシグナルサーバーのURL
+ * @returns ローカルWebRTCホスト用SDKのインスタンス
+ */
+function createLocalWebRTCHostSDK(wsSignalUrl) {
+    return new LocalWebRTCHostSDKImpl(wsSignalUrl);
+}

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

@@ -0,0 +1,39 @@
+import { ArmdozerId, PilotId } from "gbraver-burst-core";
+import { BattleSDK } from "./battle-sdk";
+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.roomID ルームID
+     * @param options.webRTCConnection WebRTCコネクションマネジャー
+     * @param options.websocketConnection WebSocketコネクションマネジャー
+     */
+    constructor(options: {
+        roomID: string;
+        webRTCConnection: HostWebRTCConnectionManager;
+        websocketConnection: WebSocketConnectionManager;
+        hostArmdozerId: ArmdozerId;
+        hostPilotId: PilotId;
+    });
+    /**
+     * マッチングするまで待機する
+     * @returns マッチングしたら発火するPromise
+     */
+    waitUntilMatching(): Promise<BattleSDK>;
+}

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

@@ -0,0 +1,106 @@
+"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_webRTCConnection, _LocalWebRTCRoomImpl_websocketConnection, _LocalWebRTCRoomImpl_hostArmdozerId, _LocalWebRTCRoomImpl_hostPilotId, _LocalWebRTCRoomImpl_signaling;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalWebRTCRoomImpl = void 0;
+const nanoid_1 = require("nanoid");
+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 wait_until_matching_1 = require("../ws-signal/wait-until-matching");
+const host_battle_sdk_1 = require("./host-battle-sdk");
+/** ローカルWebRTCルームの実装 */
+class LocalWebRTCRoomImpl {
+    /**
+     * コンストラクタ
+     * @param options ルームの生成に必要なオプション
+     * @param options.roomID ルームID
+     * @param options.webRTCConnection WebRTCコネクションマネジャー
+     * @param options.websocketConnection WebSocketコネクションマネジャー
+     */
+    constructor(options) {
+        _LocalWebRTCRoomImpl_instances.add(this);
+        /** WebRTCコネクションマネージャー */
+        _LocalWebRTCRoomImpl_webRTCConnection.set(this, void 0);
+        /** WebSocketコネクションマネージャー */
+        _LocalWebRTCRoomImpl_websocketConnection.set(this, void 0);
+        /** ホストが選択したアームドーザID */
+        _LocalWebRTCRoomImpl_hostArmdozerId.set(this, void 0);
+        /** ホストが選択したパイロットID */
+        _LocalWebRTCRoomImpl_hostPilotId.set(this, void 0);
+        const { roomID, webRTCConnection, websocketConnection, hostArmdozerId, hostPilotId, } = options;
+        this.roomID = roomID;
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_webRTCConnection, webRTCConnection, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_websocketConnection, websocketConnection, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_hostArmdozerId, hostArmdozerId, "f");
+        __classPrivateFieldSet(this, _LocalWebRTCRoomImpl_hostPilotId, hostPilotId, "f");
+    }
+    /**
+     * マッチングするまで待機する
+     * @returns マッチングしたら発火するPromise
+     */
+    waitUntilMatching() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dataChannel } = __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_webRTCConnection, "f").getOrCreateConnection();
+            yield Promise.all([
+                __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_instances, "m", _LocalWebRTCRoomImpl_signaling).call(this),
+                (0, wait_until_data_channel_ready_1.waitUntilDataChannelOpen)(dataChannel),
+            ]);
+            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_webRTCConnection = new WeakMap(), _LocalWebRTCRoomImpl_websocketConnection = 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* () {
+        try {
+            const websocket = yield __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_websocketConnection, "f").getOrCreate();
+            const signal = yield (0, wait_until_matching_1.waitUntilMatching)(websocket);
+            const { connection } = __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_webRTCConnection, "f").getOrCreateConnection();
+            yield connection.setRemoteDescription(signal.sdp);
+            yield Promise.all([
+                ...signal.iceCandidates.map((c) => connection.addIceCandidate(c)),
+            ]);
+            yield (0, wait_until_connected_1.waitUntilConnected)(connection);
+        }
+        finally {
+            __classPrivateFieldGet(this, _LocalWebRTCRoomImpl_websocketConnection, "f").gracefulDisconnect();
+        }
+    });
+};

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

@@ -0,0 +1,27 @@
+import { Observable } from "rxjs";
+export declare class WebSocketConnectionManager {
+    #private;
+    /** WebSocketシグナルサーバーのURL */
+    readonly wsSignalUrl: string;
+    /**
+     * コンストラクタ
+     * @param wsSignalUrl WebSocketシグナルサーバーのURL
+     */
+    constructor(wsSignalUrl: string);
+    /**
+     * 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,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 _WebSocketConnectionManager_websocket, _WebSocketConnectionManager_websocketError, _WebSocketConnectionManager_websocketSubscriptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketConnectionManager = void 0;
+const rxjs_1 = require("rxjs");
+const connect_ws_signal_1 = require("../ws-signal/connect-ws-signal");
+class WebSocketConnectionManager {
+    /**
+     * コンストラクタ
+     * @param wsSignalUrl WebSocketシグナルサーバーのURL
+     */
+    constructor(wsSignalUrl) {
+        /** WebSocketコネクション */
+        _WebSocketConnectionManager_websocket.set(this, null);
+        /** Web Socket エラー通知 */
+        _WebSocketConnectionManager_websocketError.set(this, void 0);
+        /** Web Socket イベントストリーム */
+        _WebSocketConnectionManager_websocketSubscriptions.set(this, void 0);
+        this.wsSignalUrl = wsSignalUrl;
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_websocketError, new rxjs_1.Subject(), "f");
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_websocketSubscriptions, [], "f");
+    }
+    /**
+     * WebSocketクライアントの取得を行う
+     * WebSocketクライアントが存在しない場合は、本メソッド内で生成してから返す
+     * @returns 取得、生成結果
+     */
+    getOrCreate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _WebSocketConnectionManager_websocket, "f")) {
+                return __classPrivateFieldGet(this, _WebSocketConnectionManager_websocket, "f");
+            }
+            const websocket = yield (0, connect_ws_signal_1.connectWSSignal)(this.wsSignalUrl);
+            __classPrivateFieldSet(this, _WebSocketConnectionManager_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")),
+            ], "f");
+            __classPrivateFieldSet(this, _WebSocketConnectionManager_websocket, websocket, "f");
+            return websocket;
+        });
+    }
+    /**
+     * Websocketコネクションを切断する
+     * 本メソッドを呼び出すことで、WebSocketコネクションに関連するイベントストリームの購読も解除する
+     */
+    gracefulDisconnect() {
+        var _a;
+        (_a = __classPrivateFieldGet(this, _WebSocketConnectionManager_websocket, "f")) === null || _a === void 0 ? void 0 : _a.close();
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_websocket, null, "f");
+        __classPrivateFieldGet(this, _WebSocketConnectionManager_websocketSubscriptions, "f").forEach((v) => {
+            v.unsubscribe();
+        });
+        __classPrivateFieldSet(this, _WebSocketConnectionManager_websocketSubscriptions, [], "f");
+    }
+    /**
+     * WebSocketのエラーを通知する
+     * @returns 通知ストリーム
+     */
+    errorNotifier() {
+        return __classPrivateFieldGet(this, _WebSocketConnectionManager_websocketError, "f");
+    }
+}
+exports.WebSocketConnectionManager = WebSocketConnectionManager;
+_WebSocketConnectionManager_websocket = new WeakMap(), _WebSocketConnectionManager_websocketError = new WeakMap(), _WebSocketConnectionManager_websocketSubscriptions = new WeakMap();

package/lib/webrtc/guest/guest-message.d.ts

@@ -0,0 +1,48 @@
+import { ArmdozerId, Command, PilotId } from "gbraver-burst-core";
+import { z } from "zod";
+/** 選択したプレイヤーをホストに送信する */
+export type SendPlayer = {
+    type: "send-player";
+    /** ゲームのフローID */
+    flowID: string;
+    /** 選択したアームドーザーのID */
+    armdozerId: ArmdozerId;
+    /** 選択したパイロットのID */
+    pilotId: PilotId;
+};
+/** SendPlayer zod のスキーマ */
+export declare const SendPlayerSchema: z.ZodObject<{
+    type: z.ZodLiteral<"send-player">;
+    flowID: z.ZodString;
+    armdozerId: z.ZodString;
+    pilotId: z.ZodString;
+}, z.core.$strip>;
+/** コマンドをホストに送信する */
+export type SendCommand = {
+    type: "send-command";
+    /** ゲームのフローID */
+    flowID: string;
+    /** コマンドの内容 */
+    command: Command;
+};
+/** SendCommand zod のスキーマ */
+export declare const SendCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"send-command">;
+    flowID: z.ZodString;
+    command: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"BATTERY_COMMAND">;
+        battery: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"BURST_COMMAND">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"PILOT_SKILL_COMMAND">;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+/** ゲストから送信されるメッセージ */
+export type GuestMessage = SendPlayer | SendCommand;
+/**
+ * ゲストメッセージをホストに送信する
+ * @param dataChannel データチャンネル
+ * @param message メッセージ内容
+ */
+export declare const sendGuestMessage: (dataChannel: RTCDataChannel, message: GuestMessage) => void;

package/lib/webrtc/guest/guest-message.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendGuestMessage = exports.SendCommandSchema = exports.SendPlayerSchema = void 0;
+const gbraver_burst_core_1 = require("gbraver-burst-core");
+const zod_1 = require("zod");
+/** SendPlayer zod のスキーマ */
+exports.SendPlayerSchema = zod_1.z.object({
+    type: zod_1.z.literal("send-player"),
+    flowID: zod_1.z.string(),
+    armdozerId: zod_1.z.string(),
+    pilotId: zod_1.z.string(),
+});
+/** SendCommand zod のスキーマ */
+exports.SendCommandSchema = zod_1.z.object({
+    type: zod_1.z.literal("send-command"),
+    flowID: zod_1.z.string(),
+    command: gbraver_burst_core_1.CommandSchema,
+});
+/**
+ * ゲストメッセージをホストに送信する
+ * @param dataChannel データチャンネル
+ * @param message メッセージ内容
+ */
+const sendGuestMessage = (dataChannel, message) => {
+    dataChannel.send(JSON.stringify(message));
+};
+exports.sendGuestMessage = sendGuestMessage;

package/lib/webrtc/guest/receive-battle-progressed.d.ts

@@ -0,0 +1,7 @@
+import { BattleProgressed } from "../host/host-message";
+/**
+ * ホストから「BattleProgressed」メッセージを待ち受ける
+ * @param dataChannel データチャネル
+ * @returns BattleProgressedメッセージの内容
+ */
+export declare const receiveBattleProgressed: (dataChannel: RTCDataChannel) => Promise<BattleProgressed>;

package/lib/webrtc/guest/receive-battle-progressed.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiveBattleProgressed = void 0;
+const parse_1 = require("../../json/parse");
+const host_message_1 = require("../host/host-message");
+/**
+ * ホストから「BattleProgressed」メッセージを待ち受ける
+ * @param dataChannel データチャネル
+ * @returns BattleProgressedメッセージの内容
+ */
+const receiveBattleProgressed = (dataChannel) => {
+    let handler = null;
+    return new Promise((resolve) => {
+        handler = (event) => {
+            const data = (0, parse_1.parseJSON)(event.data);
+            const parsedBattleProgressed = host_message_1.BattleProgressedSchema.safeParse(data);
+            if (parsedBattleProgressed.success) {
+                resolve(parsedBattleProgressed.data);
+                return;
+            }
+        };
+        dataChannel.addEventListener("message", handler);
+    }).finally(() => {
+        if (handler) {
+            dataChannel.removeEventListener("message", handler);
+        }
+    });
+};
+exports.receiveBattleProgressed = receiveBattleProgressed;

package/lib/webrtc/guest/receive-battle-start.d.ts

@@ -0,0 +1,7 @@
+import { BattleStart } from "../host/host-message";
+/**
+ * ホストから「BattleStart」メッセージを待ち受ける
+ * @param dataChannel データチャネル
+ * @returns BattleStartメッセージの内容
+ */
+export declare const receiveBattleStart: (dataChannel: RTCDataChannel) => Promise<BattleStart>;