@adeeliore/p2p-core 0.1.0

package/dist/session/P2PSession.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createP2PSession = createP2PSession;
+const constants_1 = require("./constants");
+const runtimeSupport_1 = require("./runtimeSupport");
+const serverMessageHandlers_1 = require("./serverMessageHandlers");
+const errors_1 = require("../errors");
+class P2PSessionRuntime {
+    constructor(options) {
+        this.listeners = new Map();
+        this.signalingProvider = null;
+        this.peerManager = null;
+        this.localPeerId = null;
+        this.peerIds = [];
+        this.status = 'idle';
+        this.hasOpened = false;
+        this.initialPeerIds = new Set();
+        this.scheduledOfferTimers = new Set();
+        this.options = (0, runtimeSupport_1.normalizeSessionOptions)(options);
+    }
+    connect() {
+        if (this.signalingProvider) {
+            return;
+        }
+        const provider = (0, runtimeSupport_1.createSessionSignalingProvider)(this.options);
+        const providerToken = provider;
+        const providerHandlers = (0, runtimeSupport_1.createSessionProviderHandlers)(providerToken, () => this.signalingProvider, {
+            onSignalOpen: () => {
+                this.hasOpened = true;
+                this.status = 'connected';
+                this.emit('signalingOpen', undefined);
+            },
+            onSignalClose: (event) => {
+                const hadOpened = this.hasOpened;
+                this.clearRuntime();
+                this.emit('signalingClose', {
+                    code: event.code,
+                    reason: event.reason,
+                    manual: false,
+                    hadOpened,
+                });
+            },
+            onSignalError: (message) => {
+                this.status = 'error';
+                this.emit('signalingError', {
+                    code: errors_1.P2P_CORE_ERROR_CODE.SIGNALING_PROVIDER_ERROR,
+                    message,
+                });
+            },
+            onProtocolError: (reason, rawMessage) => {
+                this.emit('protocolError', {
+                    code: errors_1.P2P_CORE_ERROR_CODE.PROTOCOL_INVALID_MESSAGE,
+                    reason,
+                    rawMessage,
+                });
+            },
+            onServerMessage: (message) => {
+                this.handleServerMessage(message);
+            },
+        });
+        try {
+            this.peerManager = (0, runtimeSupport_1.createPeerManager)(this.options, provider, this.emit.bind(this), this.resolvePeerJoinKind.bind(this));
+        }
+        catch (error) {
+            this.status = 'error';
+            this.emit('signalingError', (0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.PEER_MANAGER_UNAVAILABLE, error));
+            this.peerManager = null;
+            return;
+        }
+        this.signalingProvider = provider;
+        this.status = 'connecting';
+        const connectResult = provider.connect({
+            sessionId: this.options.sessionId,
+            clientId: this.options.clientId,
+            accessToken: this.options.accessToken,
+        }, providerHandlers);
+        if ((0, runtimeSupport_1.isPromiseLike)(connectResult)) {
+            void connectResult.catch((error) => {
+                if (this.signalingProvider !== providerToken) {
+                    return;
+                }
+                this.status = 'error';
+                this.emit('signalingError', (0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.SIGNALING_CONNECT_FAILED, error));
+            });
+        }
+    }
+    disconnect(code = constants_1.SESSION_MANUAL_DISCONNECT_CODE, reason = constants_1.SESSION_MANUAL_DISCONNECT_REASON) {
+        const hadOpened = this.hasOpened;
+        const provider = this.signalingProvider;
+        this.clearRuntime();
+        provider === null || provider === void 0 ? void 0 : provider.disconnect(code, reason);
+        this.emit('signalingClose', {
+            code,
+            reason,
+            manual: true,
+            hadOpened,
+        });
+    }
+    isConnected() {
+        var _a;
+        return this.status === 'connected' && ((_a = this.signalingProvider) === null || _a === void 0 ? void 0 : _a.isConnected()) === true;
+    }
+    getState() {
+        return (0, runtimeSupport_1.createSessionState)(this.options.sessionId, this.localPeerId, this.peerIds, this.status);
+    }
+    getLocalPeerId() {
+        return this.localPeerId;
+    }
+    getPeerIds() {
+        return [...this.peerIds];
+    }
+    sendPing() {
+        if (!this.signalingProvider) {
+            this.emit('signalingError', {
+                code: errors_1.P2P_CORE_ERROR_CODE.SIGNALING_NOT_CONNECTED,
+                message: 'Signaling provider is not connected',
+            });
+            return false;
+        }
+        try {
+            this.signalingProvider.sendPing();
+            return true;
+        }
+        catch (error) {
+            this.emit('signalingError', (0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.SIGNALING_NOT_CONNECTED, error));
+            return false;
+        }
+    }
+    sendTo(peerId, message) {
+        if (!this.peerManager) {
+            this.emit('transportError', {
+                peerId,
+                code: errors_1.P2P_CORE_ERROR_CODE.PEER_MANAGER_UNAVAILABLE,
+                message: 'WebRTC manager not ready',
+            });
+            return false;
+        }
+        try {
+            this.peerManager.sendData(peerId, message);
+            return true;
+        }
+        catch (error) {
+            this.emit('transportError', {
+                peerId,
+                ...(0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.TRANSPORT_SEND_FAILED, error),
+            });
+            return false;
+        }
+    }
+    broadcast(message, peerIds = this.peerIds) {
+        let sentCount = 0;
+        peerIds.forEach((peerId) => {
+            if (this.sendTo(peerId, message)) {
+                sentCount += 1;
+            }
+        });
+        return sentCount;
+    }
+    async createOffer(peerId) {
+        if (!this.peerManager) {
+            throw (0, runtimeSupport_1.createError)(errors_1.P2P_CORE_ERROR_CODE.PEER_MANAGER_UNAVAILABLE, 'WebRTC manager not ready');
+        }
+        await this.peerManager.createOffer(peerId);
+    }
+    on(eventName, listener) {
+        var _a;
+        const listeners = (_a = this.listeners.get(eventName)) !== null && _a !== void 0 ? _a : new Set();
+        listeners.add(listener);
+        this.listeners.set(eventName, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.listeners.delete(eventName);
+            }
+        };
+    }
+    emit(eventName, payload) {
+        const listeners = this.listeners.get(eventName);
+        listeners === null || listeners === void 0 ? void 0 : listeners.forEach((listener) => {
+            listener(payload);
+        });
+    }
+    handleServerMessage(message) {
+        (0, serverMessageHandlers_1.dispatchServerMessage)(message, {
+            onWelcome: (welcomeMessage) => {
+                this.localPeerId = welcomeMessage.clientId;
+                this.peerIds = welcomeMessage.peers.map((peer) => peer.clientId);
+                this.initialPeerIds = new Set(this.peerIds);
+                this.emit('welcome', {
+                    sessionId: welcomeMessage.sessionId,
+                    clientId: welcomeMessage.clientId,
+                    peers: [...this.peerIds],
+                });
+                if (this.options.autoCreateOffers && this.peerIds.length > 0) {
+                    this.scheduleOffers(this.peerIds);
+                }
+            },
+            onPeerJoined: (joinedMessage) => {
+                if (!this.peerIds.includes(joinedMessage.clientId)) {
+                    this.peerIds = [...this.peerIds, joinedMessage.clientId];
+                }
+                this.emit('peerJoined', { peerId: joinedMessage.clientId });
+                if (this.options.autoCreateOffers) {
+                    this.scheduleOffers([joinedMessage.clientId]);
+                }
+            },
+            onPeerLeft: (leftMessage) => {
+                var _a;
+                this.peerIds = this.peerIds.filter((peerId) => peerId !== leftMessage.clientId);
+                this.initialPeerIds.delete(leftMessage.clientId);
+                (_a = this.peerManager) === null || _a === void 0 ? void 0 : _a.closePeer(leftMessage.clientId);
+                this.emit('peerLeft', { peerId: leftMessage.clientId });
+            },
+            onRelayMessage: (relayMessage) => {
+                var _a, _b, _c;
+                const relayOperation = relayMessage.type === 'offer'
+                    ? (_a = this.peerManager) === null || _a === void 0 ? void 0 : _a.handleRemoteOffer(relayMessage.from, relayMessage.payload)
+                    : relayMessage.type === 'answer'
+                        ? (_b = this.peerManager) === null || _b === void 0 ? void 0 : _b.handleRemoteAnswer(relayMessage.from, relayMessage.payload)
+                        : (_c = this.peerManager) === null || _c === void 0 ? void 0 : _c.handleRemoteIce(relayMessage.from, relayMessage.payload);
+                void (relayOperation === null || relayOperation === void 0 ? void 0 : relayOperation.catch((error) => {
+                    this.emit('transportError', {
+                        peerId: relayMessage.from,
+                        ...(0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.RELAY_SEND_FAILED, error),
+                    });
+                }));
+            },
+            onPong: () => {
+                this.emit('pong', undefined);
+            },
+            onError: (errorMessage) => {
+                this.emit('serverError', {
+                    code: errorMessage.code,
+                    message: errorMessage.message,
+                });
+            },
+        });
+    }
+    scheduleOffers(peerIds) {
+        peerIds.forEach((peerId, index) => {
+            const timer = setTimeout(() => {
+                this.scheduledOfferTimers.delete(timer);
+                void this.createOffer(peerId).catch((error) => {
+                    this.emit('transportError', {
+                        peerId,
+                        ...(0, runtimeSupport_1.toErrorPayload)(errors_1.P2P_CORE_ERROR_CODE.RELAY_SEND_FAILED, error),
+                    });
+                });
+            }, index * this.options.offerDelayMs);
+            this.scheduledOfferTimers.add(timer);
+        });
+    }
+    clearRuntime() {
+        var _a;
+        this.clearScheduledOffers();
+        (_a = this.peerManager) === null || _a === void 0 ? void 0 : _a.closeAll();
+        this.peerManager = null;
+        this.signalingProvider = null;
+        this.localPeerId = null;
+        this.peerIds = [];
+        this.initialPeerIds.clear();
+        this.hasOpened = false;
+        this.status = 'idle';
+    }
+    clearScheduledOffers() {
+        this.scheduledOfferTimers.forEach((timer) => clearTimeout(timer));
+        this.scheduledOfferTimers.clear();
+    }
+    resolvePeerJoinKind(peerId) {
+        if (this.initialPeerIds.has(peerId)) {
+            return 'existing';
+        }
+        return 'new';
+    }
+}
+/**
+ * Creates a high-level reusable P2P session runtime.
+ *
+ * The returned session owns signaling, WebRTC orchestration and peer lifecycle,
+ * while the consuming app stays responsible for message encoding, decoding and
+ * domain-specific synchronization.
+ */
+function createP2PSession(options) {
+    return new P2PSessionRuntime(options);
+}

package/dist/session/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SESSION_DEFAULT_OFFER_DELAY_MS = 150;
+export declare const SESSION_MANUAL_DISCONNECT_CODE = 1000;
+export declare const SESSION_MANUAL_DISCONNECT_REASON = "manual_disconnect";
+//# sourceMappingURL=constants.d.ts.map

package/dist/session/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/session/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,MAAM,CAAC;AAClD,eAAO,MAAM,8BAA8B,OAAO,CAAC;AACnD,eAAO,MAAM,gCAAgC,sBAAsB,CAAC"}

package/dist/session/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_MANUAL_DISCONNECT_REASON = exports.SESSION_MANUAL_DISCONNECT_CODE = exports.SESSION_DEFAULT_OFFER_DELAY_MS = void 0;
+exports.SESSION_DEFAULT_OFFER_DELAY_MS = 150;
+exports.SESSION_MANUAL_DISCONNECT_CODE = 1000;
+exports.SESSION_MANUAL_DISCONNECT_REASON = 'manual_disconnect';

package/dist/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from './P2PSession';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/session/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./P2PSession"), exports);
+__exportStar(require("./types"), exports);

package/dist/session/runtimeSupport.d.ts

@@ -0,0 +1,36 @@
+import { WebRtcEvents, WebRtcPeerManager, WebRtcSignalType } from '../rtc/types';
+import { SignalingProvider, SignalingProviderHandlers } from '../signaling';
+import { P2PSessionEventMap, P2PSessionOptions, P2PSessionState, PeerJoinKind } from './types';
+import { P2PCoreErrorCode, P2PCoreErrorPayload } from '../errors';
+type EventEmitter = <TEvent extends keyof P2PSessionEventMap>(eventName: TEvent, payload: P2PSessionEventMap[TEvent]) => void;
+export type NormalizedSessionOptions = Required<Pick<P2PSessionOptions, 'offerDelayMs'>> & Omit<P2PSessionOptions, 'offerDelayMs' | 'heartbeat' | 'reconnect'> & {
+    heartbeat: Required<NonNullable<P2PSessionOptions['heartbeat']>>;
+    reconnect: Required<NonNullable<P2PSessionOptions['reconnect']>>;
+};
+export interface RuntimeCallbacks {
+    onSignalOpen: () => void;
+    onSignalClose: (event: {
+        code?: number;
+        reason?: string;
+    }) => void;
+    onSignalError: (message: string) => void;
+    onProtocolError: (reason: string, rawMessage: string) => void;
+    onServerMessage: SignalingProviderHandlers['onMessage'];
+}
+export declare function normalizeSessionOptions(options: P2PSessionOptions): NormalizedSessionOptions;
+export declare function createSessionSignalingProvider(options: NormalizedSessionOptions): SignalingProvider;
+export declare function createSessionProviderHandlers(providerToken: SignalingProvider, getActiveProvider: () => SignalingProvider | null, callbacks: RuntimeCallbacks): SignalingProviderHandlers;
+export declare function createSessionPeerEvents(emit: EventEmitter, resolvePeerJoinKind: (peerId: string) => PeerJoinKind): WebRtcEvents;
+export declare function createPeerSignalEmitter(provider: SignalingProvider, emit: EventEmitter): {
+    emit: (target: string, type: WebRtcSignalType, payload: unknown) => void;
+};
+export declare function createPeerManager(options: NormalizedSessionOptions, provider: SignalingProvider, emit: EventEmitter, resolvePeerJoinKind: (peerId: string) => PeerJoinKind): WebRtcPeerManager;
+export declare function createSessionState(sessionId: string, localPeerId: string | null, peerIds: string[], status: P2PSessionState['status']): P2PSessionState;
+export declare function toErrorMessage(error: unknown): string;
+export declare function toErrorPayload(code: P2PCoreErrorCode, error: unknown, fallbackMessage?: string): P2PCoreErrorPayload;
+export declare function createError(code: P2PCoreErrorCode, message: string): Error & {
+    code: P2PCoreErrorCode;
+};
+export declare function isPromiseLike(value: void | Promise<void>): value is Promise<void>;
+export {};
+//# sourceMappingURL=runtimeSupport.d.ts.map

package/dist/session/runtimeSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeSupport.d.ts","sourceRoot":"","sources":["../../src/session/runtimeSupport.ts"],"names":[],"mappings":"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"}

package/dist/session/runtimeSupport.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSessionOptions = normalizeSessionOptions;
+exports.createSessionSignalingProvider = createSessionSignalingProvider;
+exports.createSessionProviderHandlers = createSessionProviderHandlers;
+exports.createSessionPeerEvents = createSessionPeerEvents;
+exports.createPeerSignalEmitter = createPeerSignalEmitter;
+exports.createPeerManager = createPeerManager;
+exports.createSessionState = createSessionState;
+exports.toErrorMessage = toErrorMessage;
+exports.toErrorPayload = toErrorPayload;
+exports.createError = createError;
+exports.isPromiseLike = isPromiseLike;
+const signaling_1 = require("../signaling");
+const constants_1 = require("./constants");
+const errors_1 = require("../errors");
+const options_1 = require("../rtc/options");
+function normalizeSessionOptions(options) {
+    var _a;
+    return {
+        ...options,
+        offerDelayMs: (_a = options.offerDelayMs) !== null && _a !== void 0 ? _a : constants_1.SESSION_DEFAULT_OFFER_DELAY_MS,
+        heartbeat: (0, options_1.normalizeHeartbeatConfig)(options.heartbeat),
+        reconnect: (0, options_1.normalizeReconnectConfig)(options.reconnect),
+    };
+}
+function createSessionSignalingProvider(options) {
+    if (options.signalingProvider) {
+        return options.signalingProvider;
+    }
+    if (!options.signalBaseUrl) {
+        throw createError(errors_1.P2P_CORE_ERROR_CODE.SIGNALING_CONFIGURATION_REQUIRED, 'Either `signalBaseUrl` or `signalingProvider` is required');
+    }
+    return (0, signaling_1.createWebSocketSignalingProvider)({
+        signalBaseUrl: options.signalBaseUrl,
+        createSignalingClient: options.createSignalingClient,
+    });
+}
+function createSessionProviderHandlers(providerToken, getActiveProvider, callbacks) {
+    return {
+        onOpen: () => {
+            if (getActiveProvider() !== providerToken) {
+                return;
+            }
+            callbacks.onSignalOpen();
+        },
+        onClose: (event) => {
+            if (getActiveProvider() !== providerToken) {
+                return;
+            }
+            callbacks.onSignalClose(event);
+        },
+        onError: (event) => {
+            if (getActiveProvider() !== providerToken) {
+                return;
+            }
+            callbacks.onSignalError(event.message);
+        },
+        onProtocolError: callbacks.onProtocolError,
+        onMessage: (message) => {
+            var _a;
+            if (getActiveProvider() !== providerToken) {
+                return;
+            }
+            (_a = callbacks.onServerMessage) === null || _a === void 0 ? void 0 : _a.call(callbacks, message);
+        },
+    };
+}
+function createSessionPeerEvents(emit, resolvePeerJoinKind) {
+    return {
+        onDataChannelOpen: (peerId) => {
+            emit('peerDataOpen', {
+                peerId,
+                joinKind: resolvePeerJoinKind(peerId),
+            });
+        },
+        onDataChannelClosed: (peerId) => {
+            emit('peerDataClose', { peerId });
+        },
+        onDataChannelMessage: (peerId, message) => {
+            emit('peerMessage', { peerId, message });
+        },
+        onIceConnectionStateChange: (peerId, state) => {
+            emit('iceStateChange', { peerId, state });
+        },
+    };
+}
+function createPeerSignalEmitter(provider, emit) {
+    return {
+        emit: (target, type, payload) => {
+            try {
+                provider.sendRelay(type, target, payload);
+            }
+            catch (error) {
+                emit('transportError', {
+                    peerId: target,
+                    ...toErrorPayload(errors_1.P2P_CORE_ERROR_CODE.RELAY_SEND_FAILED, error),
+                });
+            }
+        },
+    };
+}
+function createPeerManager(options, provider, emit, resolvePeerJoinKind) {
+    const peerManagerOptions = {
+        signalEmitter: createPeerSignalEmitter(provider, emit),
+        events: createSessionPeerEvents(emit, resolvePeerJoinKind),
+        rtcConfig: options.rtcConfig,
+        heartbeat: options.heartbeat,
+        reconnect: options.reconnect,
+    };
+    return options.createPeerManager
+        ? options.createPeerManager(peerManagerOptions)
+        : loadDefaultPeerManagerFactory()(peerManagerOptions);
+}
+function createSessionState(sessionId, localPeerId, peerIds, status) {
+    return {
+        sessionId,
+        localPeerId,
+        peerIds: [...peerIds],
+        status,
+    };
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toErrorPayload(code, error, fallbackMessage) {
+    return {
+        code,
+        message: error instanceof Error ? error.message : fallbackMessage !== null && fallbackMessage !== void 0 ? fallbackMessage : String(error),
+    };
+}
+function createError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}
+function isPromiseLike(value) {
+    return Boolean(value && typeof value === 'object' && 'catch' in value);
+}
+function loadDefaultPeerManagerFactory() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+    const runtime = require('../rtc/runtime');
+    return runtime.createWebRtcPeerManager;
+}

package/dist/session/serverMessageHandlers.d.ts

@@ -0,0 +1,21 @@
+import { IncomingServerMessage } from '../signaling';
+export interface ServerMessageHandlerCallbacks {
+    onWelcome: (message: Extract<IncomingServerMessage, {
+        type: 'welcome';
+    }>) => void;
+    onPeerJoined: (message: Extract<IncomingServerMessage, {
+        type: 'peer-joined';
+    }>) => void;
+    onPeerLeft: (message: Extract<IncomingServerMessage, {
+        type: 'peer-left';
+    }>) => void;
+    onRelayMessage: (message: Extract<IncomingServerMessage, {
+        type: 'offer' | 'answer' | 'ice';
+    }>) => void;
+    onPong: () => void;
+    onError: (message: Extract<IncomingServerMessage, {
+        type: 'error';
+    }>) => void;
+}
+export declare function dispatchServerMessage(message: IncomingServerMessage, callbacks: ServerMessageHandlerCallbacks): void;
+//# sourceMappingURL=serverMessageHandlers.d.ts.map

package/dist/session/serverMessageHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverMessageHandlers.d.ts","sourceRoot":"","sources":["../../src/session/serverMessageHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAGrD,MAAM,WAAW,6BAA6B;IAC1C,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;IAClF,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;IACzF,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;IACrF,cAAc,EAAE,CACZ,OAAO,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAA;KAAE,CAAC,KAC5E,IAAI,CAAC;IACV,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,qBAAqB,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,KAAK,IAAI,CAAC;CACjF;AAED,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,6BAA6B,GACzC,IAAI,CAyBN"}

package/dist/session/serverMessageHandlers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchServerMessage = dispatchServerMessage;
+const constants_1 = require("../signaling/constants");
+function dispatchServerMessage(message, callbacks) {
+    switch (message.type) {
+        case constants_1.SIGNAL_TYPE.WELCOME:
+            callbacks.onWelcome(message);
+            return;
+        case constants_1.SIGNAL_TYPE.PEER_JOINED:
+            callbacks.onPeerJoined(message);
+            return;
+        case constants_1.SIGNAL_TYPE.PEER_LEFT:
+            callbacks.onPeerLeft(message);
+            return;
+        case constants_1.SIGNAL_TYPE.OFFER:
+        case constants_1.SIGNAL_TYPE.ANSWER:
+        case constants_1.SIGNAL_TYPE.ICE:
+            callbacks.onRelayMessage(message);
+            return;
+        case constants_1.SIGNAL_TYPE.PONG:
+            callbacks.onPong();
+            return;
+        case constants_1.SIGNAL_TYPE.ERROR:
+            callbacks.onError(message);
+            return;
+        default:
+            return;
+    }
+}