@observertc/observer-js 0.9.27-beta → 0.30.0-e12fcb4.0

package/lib/entries/CallEntry.js

@@ -1,75 +0,0 @@
-"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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCallEntry = exports.logger = void 0;
-const logger_1 = require("../common/logger");
-const utils_1 = require("../common/utils");
-const ClientEntry_1 = require("./ClientEntry");
-exports.logger = (0, logger_1.createLogger)('CallWrapper');
-function createCallEntry(storageProvider, model) {
-    if (!model)
-        return;
-    const { callId, roomId, serviceId, started, } = model;
-    if (!callId)
-        return exports.logger.warn(`Call model without callId: ${JSON.stringify(model)}`);
-    if (!roomId)
-        return exports.logger.warn(`Call model without roomId: ${JSON.stringify(model)}`);
-    if (!serviceId)
-        return exports.logger.warn(`Call model without serviceId: ${JSON.stringify(model)}`);
-    if (!started)
-        return exports.logger.warn(`Call model without started: ${JSON.stringify(model)}`);
-    const getClient = (clientId) => __awaiter(this, void 0, void 0, function* () {
-        return model.clientIds.includes(clientId) ? (0, ClientEntry_1.createClientEntry)(storageProvider, yield storageProvider.clientStorage.get(clientId)) : undefined;
-    });
-    const asyncClientsGenerator = function (providedClientIds) {
-        return __asyncGenerator(this, arguments, function* () {
-            const { clientStorage } = storageProvider;
-            const clientModels = yield __await(Promise.all((providedClientIds !== null && providedClientIds !== void 0 ? providedClientIds : model.clientIds).map((clientId) => clientStorage.get(clientId))));
-            for (const clientModel of clientModels) {
-                if (!clientModel)
-                    continue;
-                yield yield __await((0, ClientEntry_1.createClientEntry)(storageProvider, clientModel));
-            }
-        });
-    };
-    return {
-        callId,
-        roomId,
-        serviceId,
-        started,
-        get clientIds() {
-            return model.clientIds;
-        },
-        getClient,
-        get clients() {
-            return (0, utils_1.asyncIteratorConverter)(asyncClientsGenerator());
-        },
-        refresh: () => __awaiter(this, void 0, void 0, function* () {
-            const refreshedModel = yield storageProvider.callStorage.get(callId);
-            if (!refreshedModel)
-                return;
-            model.clientIds = refreshedModel.clientIds;
-        })
-    };
-}
-exports.createCallEntry = createCallEntry;

package/lib/entries/ClientEntry.d.ts

@@ -1,478 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-export type ClientEntry = ReturnType<typeof createClientEntry>;
-export declare function createClientEntry(storageProvider: StorageProvider, model?: Models.Client): void | {
-    clientId: string;
-    roomId: string;
-    serviceId: string;
-    mediaUnitId: string;
-    callId: string;
-    joined: bigint | undefined;
-    timeZoneId: string | undefined;
-    readonly browser: import("../models/samples_pb").Samples_ClientSample_Browser | undefined;
-    readonly engine: import("../models/samples_pb").Samples_ClientSample_Engine | undefined;
-    readonly operationSystem: import("../models/samples_pb").Samples_ClientSample_OperationSystem | undefined;
-    readonly platform: import("../models/samples_pb").Samples_ClientSample_Platform | undefined;
-    readonly peerConnectionIds: readonly string[];
-    readonly marker: string | undefined;
-    readonly coordinates: {
-        latitude: number;
-        longitude: number;
-    } | undefined;
-    getCall: () => Promise<void | {
-        callId: string;
-        roomId: string;
-        serviceId: string;
-        started: bigint;
-        readonly clientIds: readonly string[];
-        getClient: (clientId: string) => Promise<void | any>;
-        readonly clients: AsyncIterableIterator<void | any>;
-        refresh: () => Promise<void>;
-    }>;
-    readonly peerConnections: AsyncIterableIterator<void | {
-        callId: string;
-        clientId: string;
-        peerConnectionId: string;
-        marker: string | undefined;
-        label: string | undefined;
-        mediaUnitId: string | undefined;
-        opened: bigint | undefined;
-        serviceId: string | undefined;
-        roomId: string | undefined;
-        userId: string | undefined;
-        getClient: () => Promise<void | any>;
-        getCall: () => Promise<void | {
-            callId: string;
-            roomId: string;
-            serviceId: string;
-            started: bigint;
-            readonly clientIds: readonly string[];
-            getClient: (clientId: string) => Promise<void | any>;
-            readonly clients: AsyncIterableIterator<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly iceCandidatePairs: import("../models/samples_pb").Samples_ClientSample_IceCandidatePair[];
-        readonly iceRemoteCandidates: import("../models/samples_pb").Samples_ClientSample_IceRemoteCandidate[];
-        readonly iceLocalCandidates: import("../models/samples_pb").Samples_ClientSample_IceLocalCandidate[];
-        readonly transports: import("../models/samples_pb").Samples_ClientSample_PeerConnectionTransport[];
-        readonly inboundTrackIds: readonly string[];
-        readonly outboundTrackIds: readonly string[];
-        readonly inboundTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly inboundAudioTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundAudioTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly inboundVideoTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundVideoTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        getInboundTrack(inboundTrackId: string): Promise<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        getOutboundTrack(outboundTrackId: string): Promise<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        refresh(): Promise<void>;
-    }>;
-    getPeerConnection: (peerConnectionId: string) => Promise<void | {
-        callId: string;
-        clientId: string;
-        peerConnectionId: string;
-        marker: string | undefined;
-        label: string | undefined;
-        mediaUnitId: string | undefined;
-        opened: bigint | undefined;
-        serviceId: string | undefined;
-        roomId: string | undefined;
-        userId: string | undefined;
-        getClient: () => Promise<void | any>;
-        getCall: () => Promise<void | {
-            callId: string;
-            roomId: string;
-            serviceId: string;
-            started: bigint;
-            readonly clientIds: readonly string[];
-            getClient: (clientId: string) => Promise<void | any>;
-            readonly clients: AsyncIterableIterator<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly iceCandidatePairs: import("../models/samples_pb").Samples_ClientSample_IceCandidatePair[];
-        readonly iceRemoteCandidates: import("../models/samples_pb").Samples_ClientSample_IceRemoteCandidate[];
-        readonly iceLocalCandidates: import("../models/samples_pb").Samples_ClientSample_IceLocalCandidate[];
-        readonly transports: import("../models/samples_pb").Samples_ClientSample_PeerConnectionTransport[];
-        readonly inboundTrackIds: readonly string[];
-        readonly outboundTrackIds: readonly string[];
-        readonly inboundTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly inboundAudioTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundAudioTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        readonly inboundVideoTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        readonly outboundVideoTracks: AsyncIterableIterator<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        getInboundTrack(inboundTrackId: string): Promise<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "inbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_InboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_InboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh(): Promise<void>;
-        }>;
-        getOutboundTrack(outboundTrackId: string): Promise<void | {
-            callId: string;
-            clientId: string;
-            peerConnectionId: string;
-            trackId: string;
-            direction: "outbound";
-            readonly kind: "audio" | "video";
-            readonly stats: import("../models/samples_pb").Samples_ClientSample_OutboundAudioTrack[] | import("../models/samples_pb").Samples_ClientSample_OutboundVideoTrack[] | undefined;
-            readonly marker: string | undefined;
-            readonly ssrc: bigint[];
-            getCall: () => Promise<void | {
-                callId: string;
-                roomId: string;
-                serviceId: string;
-                started: bigint;
-                readonly clientIds: readonly string[];
-                getClient: (clientId: string) => Promise<void | any>;
-                readonly clients: AsyncIterableIterator<void | any>;
-                refresh: () => Promise<void>;
-            }>;
-            getClient: () => Promise<void | any>;
-            getPeerConnection: () => Promise<void | any>;
-            refresh: () => Promise<void>;
-        }>;
-        refresh(): Promise<void>;
-    }>;
-    refresh: () => Promise<void>;
-};
-//# sourceMappingURL=ClientEntry.d.ts.map

package/lib/entries/ClientEntry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientEntry.d.ts","sourceRoot":"","sources":["../../src/entries/ClientEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAK9D,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE/D,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM;;;;;;;;;;;;;;;kBA4DxD,MAAM;mBAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAoBZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBnD"}

package/lib/entries/ClientEntry.js

@@ -1,114 +0,0 @@
-"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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClientEntry = void 0;
-const CallEntry_1 = require("./CallEntry");
-const utils_1 = require("../common/utils");
-const PeerConnectionEntry_1 = require("./PeerConnectionEntry");
-function createClientEntry(storageProvider, model) {
-    if (!model)
-        return;
-    const { clientId, roomId, serviceId, mediaUnitId, callId, joined, timeZoneId, } = model;
-    if (!callId)
-        return CallEntry_1.logger.warn(`Client model without callId: ${JSON.stringify(model)}`);
-    if (!roomId)
-        return CallEntry_1.logger.warn(`Client model without roomId: ${JSON.stringify(model)}`);
-    if (!clientId)
-        return CallEntry_1.logger.warn(`Client model without clientId: ${JSON.stringify(model)}`);
-    if (!serviceId)
-        return CallEntry_1.logger.warn(`Client model without serviceId: ${JSON.stringify(model)}`);
-    if (!mediaUnitId)
-        return CallEntry_1.logger.warn(`Client model without mediaUnitId: ${JSON.stringify(model)}`);
-    const getCall = () => __awaiter(this, void 0, void 0, function* () {
-        return (0, CallEntry_1.createCallEntry)(storageProvider, yield storageProvider.callStorage.get(callId));
-    });
-    const asyncPeerConnectionGenerator = function (providedPeerConnectionIds) {
-        return __asyncGenerator(this, arguments, function* () {
-            const peerConnectionModels = yield __await(Promise.all((providedPeerConnectionIds !== null && providedPeerConnectionIds !== void 0 ? providedPeerConnectionIds : model.peerConnectionIds).map((peerConnectionId) => storageProvider.peerConnectionStorage.get(peerConnectionId))));
-            for (const peerConnectionModel of peerConnectionModels) {
-                if (!peerConnectionModel)
-                    continue;
-                yield yield __await((0, PeerConnectionEntry_1.createPeerConnectionEntry)(storageProvider, peerConnectionModel));
-            }
-        });
-    };
-    return {
-        clientId,
-        roomId,
-        serviceId,
-        mediaUnitId,
-        callId,
-        joined,
-        timeZoneId,
-        get browser() {
-            return model.browser;
-        },
-        get engine() {
-            return model.engine;
-        },
-        get operationSystem() {
-            return model.operationSystem;
-        },
-        get platform() {
-            return model.platform;
-        },
-        get peerConnectionIds() {
-            return model.peerConnectionIds;
-        },
-        get marker() {
-            return model.marker;
-        },
-        get coordinates() {
-            if (!model.coordinates)
-                return;
-            const { longitude, latitude } = model.coordinates;
-            if (!latitude)
-                return;
-            if (!longitude)
-                return;
-            return {
-                latitude,
-                longitude
-            };
-        },
-        getCall,
-        get peerConnections() {
-            return (0, utils_1.asyncIteratorConverter)(asyncPeerConnectionGenerator());
-        },
-        getPeerConnection: (peerConnectionId) => __awaiter(this, void 0, void 0, function* () {
-            return model.peerConnectionIds.includes(peerConnectionId) ? (0, PeerConnectionEntry_1.createPeerConnectionEntry)(storageProvider, yield storageProvider.peerConnectionStorage.get(peerConnectionId)) : undefined;
-        }),
-        refresh: () => __awaiter(this, void 0, void 0, function* () {
-            const refreshedModel = yield storageProvider.clientStorage.get(clientId);
-            if (!refreshedModel)
-                return;
-            model.browser = refreshedModel.browser;
-            model.engine = refreshedModel.engine;
-            model.operationSystem = refreshedModel.operationSystem;
-            model.platform = refreshedModel.platform;
-            model.peerConnectionIds = refreshedModel.peerConnectionIds;
-            model.marker = refreshedModel.marker;
-        })
-    };
-}
-exports.createClientEntry = createClientEntry;