@observertc/observer-js 0.9.27-beta → 0.30.0-beta

package/src/entries/InboundTrackEntry.ts

@@ -1,74 +0,0 @@
-import { createLogger } from '../common/logger';
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { createCallEntry } from './CallEntry';
-import { createClientEntry } from './ClientEntry';
-import { createPeerConnectionEntry } from './PeerConnectionEntry';
-
-const logger = createLogger('InboundTrackWrapper');
-
-export type InboundTrackEntry = ReturnType<typeof createInboundTrackEntry>;
-
-export function createInboundTrackEntry(storageProvider: StorageProvider, model?: Models.InboundTrack) {
-	if (!model) return;
-	const {
-		callId,
-		clientId,
-		peerConnectionId,
-		trackId,
-		kind,
-	} = model;
-
-	if (!callId) return logger.warn(`InboundTrack model without callId: ${JSON.stringify(model)}`);
-	if (!clientId) return logger.warn(`InboundTrack model without clientId: ${JSON.stringify(model)}`);
-	if (!peerConnectionId) return logger.warn(`InboundTrack model without peerConnectionId: ${JSON.stringify(model)}`);
-	if (!trackId) return logger.warn(`InboundTrack model without trackId: ${JSON.stringify(model)}`);
-	if (!kind) return logger.warn(`InboundTrack model without kind: ${JSON.stringify(model)}`);
-
-	const direction = 'inbound' as const;
-	const getCall = async () => {
-		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
-	};
-	const getClient = async () => {
-		return createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId));
-	};
-	const getPeerConnection = async () => {
-		return createPeerConnectionEntry(storageProvider, await storageProvider.peerConnectionStorage.get(peerConnectionId));
-	};
-
-	return {
-		callId,
-		clientId,
-		peerConnectionId,
-		trackId,
-		direction,
-		get kind(): 'audio' | 'video' {
-			return kind.toLocaleLowerCase() as 'audio' | 'video';
-		},
-		get stats() {
-			return 0 < model.audioStats.length ? model.audioStats : 0 < model.videoStats.length ? model.videoStats : undefined;
-		},
-		get marker() {
-			return model.marker;
-		},
-		get ssrc() {
-			return model.ssrc;
-		},
-
-		getCall,
-		getClient,
-		getPeerConnection,
-
-		async refresh() {
-			const refreshedModel = await storageProvider.inboundTrackStorage.get(trackId);
-
-			if (!refreshedModel) return;
-
-			model.audioStats = refreshedModel.audioStats;
-			model.videoStats = refreshedModel.videoStats;
-			model.marker = refreshedModel.marker;
-			model.ssrc = refreshedModel.ssrc;
-		}
-
-	};
-}

package/src/entries/OutboundTrackEntry.ts

@@ -1,72 +0,0 @@
-import { createLogger } from '../common/logger';
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { createCallEntry } from './CallEntry';
-import { createClientEntry } from './ClientEntry';
-import { createPeerConnectionEntry } from './PeerConnectionEntry';
-
-const logger = createLogger('OutboundTrackWrapper');
-
-export type OutboundTrackEntry = ReturnType<typeof createOutboundTrackEntry>;
-
-export function createOutboundTrackEntry(storageProvider: StorageProvider, model?: Models.OutboundTrack) {
-	if (!model) return;
-	const {
-		callId,
-		clientId,
-		peerConnectionId,
-		trackId,
-		kind,
-	} = model;
-
-	if (!callId) return logger.warn(`OutboundTrack model without callId: ${JSON.stringify(model)}`);
-	if (!clientId) return logger.warn(`OutboundTrack model without clientId: ${JSON.stringify(model)}`);
-	if (!peerConnectionId) return logger.warn(`OutboundTrack model without peerConnectionId: ${JSON.stringify(model)}`);
-	if (!trackId) return logger.warn(`OutboundTrack model without trackId: ${JSON.stringify(model)}`);
-	if (!kind) return logger.warn(`OutboundTrack model without kind: ${JSON.stringify(model)}`);
-	
-	const direction = 'outbound' as const;
-	const getCall = async () => {
-		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
-	};
-	const getClient = async () => {
-		return createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId));
-	};
-	const getPeerConnection = async () => {
-		return createPeerConnectionEntry(storageProvider, await storageProvider.peerConnectionStorage.get(peerConnectionId));
-	};
-	
-	return {
-		callId,
-		clientId,
-		peerConnectionId,
-		trackId,
-		direction,
-		get kind(): 'audio' | 'video' {
-			return kind.toLocaleLowerCase() as 'audio' | 'video';
-		},
-		get stats() {
-			return 0 < model.audioStats.length ? model.audioStats : 0 < model.videoStats.length ? model.videoStats : undefined;
-		},
-		get marker() {
-			return model.marker;
-		},
-		get ssrc() {
-			return model.ssrc;
-		},
-
-		getCall,
-		getClient,
-		getPeerConnection,
-
-		refresh: async () => {
-			const refreshedModel = await storageProvider.outboundTrackStorage.get(trackId);
-
-			if (!refreshedModel) return;
-
-			model.audioStats = refreshedModel.audioStats;
-			model.videoStats = refreshedModel.videoStats;
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/entries/PeerConnectionEntry.ts

@@ -1,133 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { logger, createCallEntry } from './CallEntry';
-import { asyncIteratorConverter } from '../common/utils';
-import { createClientEntry } from './ClientEntry';
-import { InboundTrackEntry, createInboundTrackEntry } from './InboundTrackEntry';
-import { OutboundTrackEntry, createOutboundTrackEntry } from './OutboundTrackEntry';
-
-export type PeerConnectionEntry = ReturnType<typeof createPeerConnectionEntry>;
-
-export function createPeerConnectionEntry(storageProvider: StorageProvider, model?: Models.PeerConnection) {
-	if (!model) return;
-
-	const {
-		callId, 
-		clientId, 
-		peerConnectionId, 
-		label,
-		mediaUnitId, 
-		opened, 
-		serviceId, 
-		roomId, 
-		userId, 
-		marker
-	} = model;
-
-	if (!peerConnectionId) return logger.warn(`PeerConnection model without peerConnectionId: ${JSON.stringify(model)}`);
-	if (!callId) return logger.warn(`PeerConnection model without callId: ${JSON.stringify(model)}`);
-	if (!clientId) return logger.warn(`PeerConnection model without clientId: ${JSON.stringify(model)}`);
-
-	const getClient = async () => {
-		return createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId));
-	};
-
-	const getCall = async () => {
-		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
-	};
-
-	const asyncInboundTrackGenerator = async function *(providedInboundTrackIds?: string[], kind?: string) {
-		const inboundTrackModels = await Promise.all(
-			(providedInboundTrackIds ?? model.inboundTrackIds).map((inboundTrackId) => storageProvider.inboundTrackStorage.get(inboundTrackId))
-		);
-
-		for (const inboundTrackModel of inboundTrackModels) {
-			if (!inboundTrackModel) continue;
-			if (kind && inboundTrackModel.kind !== kind) continue;
-			yield createInboundTrackEntry(storageProvider, inboundTrackModel);
-		}
-	};
-	const asyncOutboundTrackGenerator = async function *(providedOutboundTrackIds?: string[], kind?: string) {
-		const outboundTrackModels = await Promise.all(
-			(providedOutboundTrackIds ?? model.outboundTrackIds).map((outboundTrackId) => storageProvider.outboundTrackStorage.get(outboundTrackId))
-		);
-
-		for (const outboundTrackModel of outboundTrackModels) {
-			if (!outboundTrackModel) continue;
-			if (kind && outboundTrackModel.kind !== kind) continue;
-			yield createOutboundTrackEntry(storageProvider, outboundTrackModel);
-		}
-	};
-
-	return {
-		callId,
-		clientId,
-		peerConnectionId,
-		marker,
-		label,
-		mediaUnitId,
-		opened,
-		serviceId,
-		roomId,
-		userId,
-
-		getClient,
-		getCall,
-		
-		get iceCandidatePairs() {
-			return model.iceCandidatePairs;
-		},
-		get iceRemoteCandidates() {
-			return model.iceRemoteCandidates;
-		},
-		get iceLocalCandidates() {
-			return model.icelocalCandidates;
-		},
-		get transports() {
-			return model.transports;
-		},
-		get inboundTrackIds(): ReadonlyArray<string> {
-			return model.inboundTrackIds;
-		},
-		get outboundTrackIds(): ReadonlyArray<string> {
-			return model.outboundTrackIds;
-		},
-		get inboundTracks(): AsyncIterableIterator<InboundTrackEntry> {
-			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator());
-		},
-		get outboundTracks(): AsyncIterableIterator<OutboundTrackEntry> {
-			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator());
-		},
-		get inboundAudioTracks(): AsyncIterableIterator<InboundTrackEntry> {
-			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator(undefined, 'audio'));
-		},
-		get outboundAudioTracks(): AsyncIterableIterator<OutboundTrackEntry> {
-			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator(undefined, 'audio'));
-		},
-		get inboundVideoTracks(): AsyncIterableIterator<InboundTrackEntry> {
-			return asyncIteratorConverter<InboundTrackEntry>(asyncInboundTrackGenerator(undefined, 'video'));
-		},
-		get outboundVideoTracks(): AsyncIterableIterator<OutboundTrackEntry> {
-			return asyncIteratorConverter<OutboundTrackEntry>(asyncOutboundTrackGenerator(undefined, 'video'));
-		},
-		async getInboundTrack(inboundTrackId: string) {
-			return model.inboundTrackIds.includes(inboundTrackId) ? createInboundTrackEntry(storageProvider, await storageProvider.inboundTrackStorage.get(inboundTrackId)) : undefined;
-		},
-		async getOutboundTrack(outboundTrackId: string) {
-			return model.outboundTrackIds.includes(outboundTrackId) ? createOutboundTrackEntry(storageProvider, await storageProvider.outboundTrackStorage.get(outboundTrackId)) : undefined;
-		},
-
-		async refresh() {
-			const refreshedModel = await storageProvider.peerConnectionStorage.get(peerConnectionId);
-
-			if (!refreshedModel) return;
-
-			model.iceCandidatePairs = refreshedModel.iceCandidatePairs;
-			model.iceRemoteCandidates = refreshedModel.iceRemoteCandidates;
-			model.icelocalCandidates = refreshedModel.icelocalCandidates;
-			model.transports = refreshedModel.transports;
-			model.inboundTrackIds = refreshedModel.inboundTrackIds;
-			model.outboundTrackIds = refreshedModel.outboundTrackIds;
-		}
-	};
-}

package/src/entries/SfuEntry.ts

@@ -1,62 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { createLogger } from '../common/logger';
-import { SfuTransportEntry, createSfuTransportEntry } from './SfuTransportEntry';
-import { asyncIteratorConverter } from '../common/utils';
-
-export const logger = createLogger('CallWrapper');
-
-export type SfuEntry = ReturnType<typeof createSfuEntry>;
-
-export function createSfuEntry(storageProvider: StorageProvider, model?: Models.Sfu) {
-	if (!model) return;
-	const { 
-		sfuId,
-		serviceId,
-		mediaUnitId,
-		joined,
-	} = model;
-
-	if (!sfuId) return logger.warn(`Sfu model without sfuId: ${JSON.stringify(model)}`);
-	if (!serviceId) return logger.warn(`Sfu model without serviceId: ${JSON.stringify(model)}`);
-	if (!mediaUnitId) return logger.warn(`Sfu model without mediaUnitId: ${JSON.stringify(model)}`);
-	if (!joined) return logger.warn(`Sfu model without joined: ${JSON.stringify(model)}`);
-
-	const getSfuTransport = async (sfuTransportId: string) => {
-		return createSfuTransportEntry(storageProvider, await storageProvider.sfuTransportStorage.get(sfuTransportId));
-	};
-	const asyncSfuTransportGenerator = async function *() {
-		const sfuTransportModels = await Promise.all(
-			model.sfuTransportIds.map((sfuTransportId) => storageProvider.sfuTransportStorage.get(sfuTransportId))
-		);
-
-		for (const sfuTransportModel of sfuTransportModels) {
-			if (!sfuTransportModel) continue;
-			yield createSfuTransportEntry(storageProvider, sfuTransportModel);
-		}
-	};
-	
-	return {
-		sfuId,
-		serviceId,
-		mediaUnitId,
-		joined,
-		get marker() {
-			return model.marker;
-		},
-		get sfuTransportIds(): ReadonlyArray<string> {
-			return model.sfuTransportIds;
-		},
-		get sfuTransports(): AsyncIterableIterator<SfuTransportEntry> {
-			return asyncIteratorConverter<SfuTransportEntry>(asyncSfuTransportGenerator());
-		},
-		getSfuTransport,
-		refresh: async () => {
-			const refreshedModel = await storageProvider.sfuStorage.get(sfuId);
-
-			if (!refreshedModel) return;
-
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/entries/SfuInboundRtpPadEntry.ts

@@ -1,46 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { logger } from './SfuEntry';
-
-export type SfuInboundRtpPadEntry = ReturnType<typeof createSfuInboundRtpPadEntry>;
-
-export function createSfuInboundRtpPadEntry(storageProvider: StorageProvider, model?: Models.SfuInboundRtpPad) {
-	if (!model) return;
-	const {
-		sfuId, 
-		sfuTransportId,
-		added,
-		internal,
-		rtpPadId,
-		mediaUnitId,
-	} = model;
-
-	if (!sfuId) return logger.warn(`SfuInboundRtpPad model without sfuId: ${JSON.stringify(model)}`);
-	if (!sfuTransportId) return logger.warn(`SfuInboundRtpPad model without sfuTransportId: ${JSON.stringify(model)}`);
-	if (!added) return logger.warn(`SfuInboundRtpPad model without added: ${JSON.stringify(model)}`);
-	if (!rtpPadId) return logger.warn(`SfuInboundRtpPad model without rtpPadId: ${JSON.stringify(model)}`);
-	if (!mediaUnitId) return logger.warn(`SfuInboundRtpPad model without mediaUnitId: ${JSON.stringify(model)}`);
-
-	const direction = 'inbound' as const;
-
-	return {
-		sfuId,
-		sfuTransportId,
-		rtpPadId,
-		direction,
-		added,
-		get internal() {
-			return internal === true;
-		},
-		get marker() {
-			return model.marker;
-		},
-		refresh: async () => {
-			const refreshedModel = await storageProvider.sfuInboundRtpPadStorage.get(sfuTransportId);
-
-			if (!refreshedModel) return;
-
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/entries/SfuOutboundRtpPadEntry.ts

@@ -1,44 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { logger } from './SfuEntry';
-
-export type SfuOutboundRtpPadEntry = ReturnType<typeof createSfuOutboundRtpPadEntry>;
-
-export function createSfuOutboundRtpPadEntry(storageProvider: StorageProvider, model?: Models.SfuOutboundRtpPad) {
-	if (!model) return;
-	const {
-		sfuId, 
-		sfuTransportId,
-		rtpPadId,
-		added,
-		internal,
-	} = model;
-
-	if (!sfuId) return logger.warn(`SfuTransport model without sfuId: ${JSON.stringify(model)}`);
-	if (!sfuTransportId) return logger.warn(`SfuTransport model without sfuTransportId: ${JSON.stringify(model)}`);
-	if (!rtpPadId) return logger.warn(`SfuTransport model without rtpPadId: ${JSON.stringify(model)}`);
-	if (!added) return logger.warn(`SfuTransport model without added: ${JSON.stringify(model)}`);
-	
-	const direction = 'outbound' as const;
-
-	return {
-		sfuTransportId,
-		sfuId,
-		rtpPadId,
-		added,
-		direction,
-		get internal() {
-			return internal === true;
-		},
-		get marker() {
-			return model.marker;
-		},
-		refresh: async () => {
-			const refreshedModel = await storageProvider.sfuTransportStorage.get(sfuTransportId);
-
-			if (!refreshedModel) return;
-
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/entries/SfuSctpChannelEntry.ts

@@ -1,39 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { logger } from './SfuEntry';
-
-export type SfuSctpChannelEntry = ReturnType<typeof createSfuSctpChannelEntry>;
-
-export function createSfuSctpChannelEntry(storageProvider: StorageProvider, model?: Models.SfuSctpChannel) {
-	if (!model) return;
-	const {
-		sfuId,
-		sfuTransportId,
-		sfuSctpChannelId,
-		opened,
-	} = model;
-
-	model.sfuTransportId;
-
-	if (!sfuId) return logger.warn(`SfuSctpChannel model without sfuId: ${JSON.stringify(model)}`);
-	if (!sfuTransportId) return logger.warn(`SfuSctpChannel model without sfuTransportId: ${JSON.stringify(model)}`);
-	if (!sfuSctpChannelId) return logger.warn(`SfuSctpChannel model without sfuSctpChannelId: ${JSON.stringify(model)}`);
-	if (!opened) return logger.warn(`SfuSctpChannel model without opened: ${JSON.stringify(model)}`);
-
-	return {
-		sfuId,
-		sfuTransportId,
-		sfuSctpChannelId,
-		opened,
-		get marker() {
-			return model.marker;
-		},
-		refresh: async () => {
-			const refreshedModel = await storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId);
-
-			if (!refreshedModel) return;
-
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/entries/SfuTransportEntry.ts

@@ -1,109 +0,0 @@
-import { asyncIteratorConverter } from '../common/utils';
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { createSfuEntry, logger } from './SfuEntry';
-import { createSfuInboundRtpPadEntry } from './SfuInboundRtpPadEntry';
-import { createSfuOutboundRtpPadEntry } from './SfuOutboundRtpPadEntry';
-import { createSfuSctpChannelEntry } from './SfuSctpChannelEntry';
-
-export type SfuTransportEntry = ReturnType<typeof createSfuTransportEntry>;
-
-export function createSfuTransportEntry(storageProvider: StorageProvider, model?: Models.SfuTransport) {
-	if (!model) return;
-	const {
-		sfuId,
-		transportId: sfuTransportId,
-		opened,
-		internal,
-	} = model;
-
-	if (!sfuId) return logger.warn(`SfuTransport model without sfuId: ${JSON.stringify(model)}`);
-	if (!sfuTransportId) return logger.warn(`SfuTransport model without sfuTransportId: ${JSON.stringify(model)}`);
-	if (!opened) return logger.warn(`SfuTransport model without opened: ${JSON.stringify(model)}`);
-	
-	const getSfu = async () => {
-		return createSfuEntry(storageProvider, await storageProvider.sfuStorage.get(sfuId));
-	};
-	const getSfuInboundRtpPad = async (sfuInboundRtpPadId: string) => {
-		return createSfuInboundRtpPadEntry(storageProvider, await storageProvider.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId));
-	};
-	const getSfuOutboundRtpPad = async (sfuOutboundRtpPadId: string) => {
-		return createSfuOutboundRtpPadEntry(storageProvider, await storageProvider.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId));
-	};
-	const getSfuSctpChannel = async (sfuSctpChannelId: string) => {
-		return createSfuSctpChannelEntry(storageProvider, await storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId));
-	};
-	const asyncSfuInboundRtpPadGenerator = async function *() {
-		const sfuInboundRtpPadModels = await Promise.all(
-			model.inboundRtpPadIds.map((sfuInboundRtpPadId) => storageProvider.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId))
-		);
-
-		for (const sfuInboundRtpPadModel of sfuInboundRtpPadModels) {
-			if (!sfuInboundRtpPadModel) continue;
-			yield createSfuInboundRtpPadEntry(storageProvider, sfuInboundRtpPadModel);
-		}
-	};
-
-	const asyncSfuOutboundRtpPadGenerator = async function *() {
-		const sfuOutboundRtpPadModels = await Promise.all(
-			model.outboundRtpPadIds.map((sfuOutboundRtpPadId) => storageProvider.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId))
-		);
-
-		for (const sfuOutboundRtpPadModel of sfuOutboundRtpPadModels) {
-			if (!sfuOutboundRtpPadModel) continue;
-			yield createSfuOutboundRtpPadEntry(storageProvider, sfuOutboundRtpPadModel);
-		}
-	};
-
-	const asyncSfuSctpChannelGenerator = async function *() {
-		const sfuSctpChannelModels = await Promise.all(
-			model.sctpChannelIds.map((sfuSctpChannelId) => storageProvider.sfuSctpChannelStorage.get(sfuSctpChannelId))
-		);
-
-		for (const sfuSctpChannelModel of sfuSctpChannelModels) {
-			if (!sfuSctpChannelModel) continue;
-			yield createSfuSctpChannelEntry(storageProvider, sfuSctpChannelModel);
-		}
-	};
-
-	return {
-		sfuTransportId,
-		sfuId,
-		opened,
-		get internal() {
-			return internal === true;
-		},
-		get marker() {
-			return model.marker;
-		},
-		get inboundRtpPadIds(): ReadonlyArray<string> {
-			return model.inboundRtpPadIds;
-		},
-		get outboundRtpPadIds(): ReadonlyArray<string> {
-			return model.outboundRtpPadIds;
-		},
-		get sctpChannelIds(): ReadonlyArray<string> {
-			return model.sctpChannelIds;
-		},
-		get inboundRtpPads(): AsyncIterableIterator<ReturnType<typeof createSfuInboundRtpPadEntry>> {
-			return asyncIteratorConverter<ReturnType<typeof createSfuInboundRtpPadEntry>>(asyncSfuInboundRtpPadGenerator());
-		},
-		get outboundRtpPads(): AsyncIterableIterator<ReturnType<typeof createSfuOutboundRtpPadEntry>> {
-			return asyncIteratorConverter<ReturnType<typeof createSfuOutboundRtpPadEntry>>(asyncSfuOutboundRtpPadGenerator());
-		},
-		get sctpChannels(): AsyncIterableIterator<ReturnType<typeof createSfuSctpChannelEntry>> {
-			return asyncIteratorConverter<ReturnType<typeof createSfuSctpChannelEntry>>(asyncSfuSctpChannelGenerator());
-		},
-		getSfu,
-		getSfuInboundRtpPad,
-		getSfuOutboundRtpPad,
-		getSfuSctpChannel,
-		refresh: async () => {
-			const refreshedModel = await storageProvider.sfuTransportStorage.get(sfuTransportId);
-
-			if (!refreshedModel) return;
-
-			model.marker = refreshedModel.marker;
-		}
-	};
-}

package/src/evaluators/SetClientsCoordinateEvaluator.ts

@@ -1,78 +0,0 @@
-import { createLogger } from '../common/logger';
-import * as Models from '../models/Models';
-import ipaddr from 'ipaddr.js';
-import { EvaluatorProcess } from '..';
-
-export const logger = createLogger('SetClientsCoordinateEvaluator');
-
-export type ClientCoordinate = {
-	latitude: number;
-	longitude: number;
-};
-
-export type GetClientCoordinate = (ipAddress: string) => ClientCoordinate | undefined;
-
-export function createSetClientsCoordinateEvaluator(
-	getCoordinate: GetClientCoordinate,
-): EvaluatorProcess {
-	const process: EvaluatorProcess = async (context) => {
-
-		const clientIds = new Set<string>();
-
-		for (const observedCall of context.observedCalls.observedCalls()) {
-			for (const observedClient of observedCall.observedClients()) {
-				clientIds.add(observedClient.clientId);
-			}
-		}
-		if (clientIds.size < 1) return;
-
-		const storedClients = await context.storages.clientStorage.getAll(clientIds);
-		
-		for (const observedCall of context.observedCalls.observedCalls()) {
-			for (const observedClient of observedCall.observedClients()) {
-				const { clientId } = observedClient;
-				const storedClient = storedClients.get(clientId);
-
-				if (!storedClient || storedClient.coordinates) continue;
-				
-				let ipAddress: string | undefined;
-
-				searchForIp: for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-					for (const iceLocalCandidate of observedPeerConnection.iceLocalCandidates()) {
-						if (!iceLocalCandidate.address) continue;
-
-						try {
-							const addr = ipaddr.parse(iceLocalCandidate.address);
-							
-							ipAddress = addr.toString();
-
-							break searchForIp;
-						} catch (e) {
-							logger.warn(`Failed to parse ip address: ${iceLocalCandidate.address}`, e);
-
-							continue;
-						}
-						
-					}
-				}
-
-				if (!ipAddress) continue;
-
-				try {
-					const coordinate = getCoordinate(ipAddress);
-
-					if (!coordinate) continue;
-
-					storedClient.coordinates = new Models.ClientCoordinate({
-						latitude: coordinate.latitude,
-						longitude: coordinate.longitude,
-					});
-				} catch (e) {
-					logger.warn(`Failed to get coordinate for ip address: ${ipAddress}`, e);
-				}
-			}
-		}
-	};
-	
-	return process;
-}