@observertc/observer-js 1.0.1-ec27289.0 → 1.1.0

package/src/ObservedPeerConnectionTransport.ts

@@ -1,38 +0,0 @@
-import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { PeerConnectionTransportStats } from './schema/ClientSample';
-
-export class ObservedPeerConnectionTransport implements PeerConnectionTransportStats {
-	private _visited = false;
-	public appData?: Record<string, unknown>;
-
-	dataChannelsOpened?: number | undefined;
-	dataChannelsClosed?: number | undefined;
-	attachments?: Record<string, unknown> | undefined;
-
-	public constructor(
-		public timestamp: number,
-		public id: string,
-		private readonly _peerConnection: ObservedPeerConnection
-	) {}
-
-	public get visited() {
-		const visited = this._visited;
-
-		this._visited = false;
-
-		return visited;
-	}
-
-	public getPeerConnection() {
-		return this._peerConnection;
-	}
-
-	public update(stats: PeerConnectionTransportStats) {
-		this._visited = true;
-
-		this.timestamp = stats.timestamp;
-		this.dataChannelsOpened = stats.dataChannelsOpened;
-		this.dataChannelsClosed = stats.dataChannelsClosed;
-		this.attachments = stats.attachments;
-	}
-}

package/src/ObservedRemoteInboundRtp.ts

@@ -1,64 +0,0 @@
-import { MediaKind } from './common/types';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { RemoteInboundRtpStats } from './schema/ClientSample';
-
-export class ObservedRemoteInboundRtp implements RemoteInboundRtpStats {
-	private _visited = false;
-	public appData?: Record<string, unknown>;
-	transportId?: string | undefined;
-	codecId?: string | undefined;
-	packetsReceived?: number | undefined;
-	packetsLost?: number | undefined;
-	jitter?: number | undefined;
-	localId?: string | undefined;
-	roundTripTime?: number | undefined;
-	totalRoundTripTime?: number | undefined;
-	fractionLost?: number | undefined;
-	roundTripTimeMeasurements?: number | undefined;
-	attachments?: Record<string, unknown> | undefined;
-
-	public constructor(
-		public timestamp: number,
-		public id: string,
-		public ssrc: number,
-		public kind: MediaKind,
-		private readonly _peerConnection: ObservedPeerConnection
-	) {}
-
-	public get visited() {
-		const visited = this._visited;
-
-		this._visited = false;
-
-		return visited;
-	}
-
-	public getPeerConnection() {
-		return this._peerConnection;
-	}
-
-	public getOutboundRtp() {
-		return this._peerConnection.observedOutboundRtps.get(this.ssrc);
-	}
-
-	public getCodec() {
-		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
-	}
-
-	public update(stats: RemoteInboundRtpStats) {
-		this._visited = true;
-
-		this.timestamp = stats.timestamp;
-		this.transportId = stats.transportId;
-		this.codecId = stats.codecId;
-		this.packetsReceived = stats.packetsReceived;
-		this.packetsLost = stats.packetsLost;
-		this.jitter = stats.jitter;
-		this.localId = stats.localId;
-		this.roundTripTime = stats.roundTripTime;
-		this.totalRoundTripTime = stats.totalRoundTripTime;
-		this.fractionLost = stats.fractionLost;
-		this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
-		this.attachments = stats.attachments;
-	}
-}

package/src/ObservedRemoteOutboundRtp.ts

@@ -1,65 +0,0 @@
-import { MediaKind } from './common/types';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { RemoteOutboundRtpStats } from './schema/ClientSample';
-
-export class ObservedRemoteOutboundRtp implements RemoteOutboundRtpStats {
-	private _visited = false;
-	public appData?: Record<string, unknown>;
-
-	transportId?: string | undefined;
-	codecId?: string | undefined;
-	packetsSent?: number | undefined;
-	bytesSent?: number | undefined;
-	localId?: string | undefined;
-	remoteTimestamp?: number | undefined;
-	reportsSent?: number | undefined;
-	roundTripTime?: number | undefined;
-	totalRoundTripTime?: number | undefined;
-	roundTripTimeMeasurements?: number | undefined;
-	attachments?: Record<string, unknown> | undefined;
-
-	public constructor(
-		public timestamp: number,
-		public id: string,
-		public ssrc: number,
-		public kind: MediaKind,
-		private readonly _peerConnection: ObservedPeerConnection
-	) {}
-
-	public get visited() {
-		const visited = this._visited;
-
-		this._visited = false;
-
-		return visited;
-	}
-
-	public getPeerConnection() {
-		return this._peerConnection;
-	}
-
-	public getInboundRtp() {
-		return this._peerConnection.observedInboundRtps.get(this.ssrc);
-	}
-
-	public getCodec() {
-		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
-	}
-
-	public update(stats: RemoteOutboundRtpStats) {
-		this._visited = true;
-
-		this.timestamp = stats.timestamp;
-		this.transportId = stats.transportId;
-		this.codecId = stats.codecId;
-		this.packetsSent = stats.packetsSent;
-		this.bytesSent = stats.bytesSent;
-		this.localId = stats.localId;
-		this.remoteTimestamp = stats.remoteTimestamp;
-		this.reportsSent = stats.reportsSent;
-		this.roundTripTime = stats.roundTripTime;
-		this.totalRoundTripTime = stats.totalRoundTripTime;
-		this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
-		this.attachments = stats.attachments;
-	}
-}

package/src/ObservedTURN.ts

@@ -1,86 +0,0 @@
-import { EventEmitter } from 'stream';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { ObservedTurnServer } from './ObservedTurnServer';
-import { createLogger } from './common/logger';
-
-const logger = createLogger('ObservedTURN');
-
-export type ObservedTURNEventMap = {
-	'update': [ObservedTURN];
-	'close': [];
-}
-
-export declare interface ObservedTURN {
-	on<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
-	off<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
-	once<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
-	emit<U extends keyof ObservedTURNEventMap>(event: U, ...args: ObservedTURNEventMap[U]): boolean;
-}
-
-export class ObservedTURN extends EventEmitter {
-	public totalBytesSent = 0;
-	public totalBytesReceived = 0;
-	public totalPacketsSent = 0;
-	public totalPacketsReceived = 0;
-
-	public packetsSentPerSecond = 0;
-	public packetsReceivedPerSecond = 0;
-	public outboundBitrate = 0;
-	public inboundBitrate = 0;
-	public numberOfClients = 0;
-    
-	public readonly servers = new Map<string, ObservedTurnServer>();
-
-	public constructor(
-	) {
-		super();
-	}
-
-	public update() {
-		const clientIds = new Set<string>();
-        
-		this.packetsReceivedPerSecond = 0;
-		this.packetsSentPerSecond = 0;
-		this.outboundBitrate = 0;
-		this.inboundBitrate = 0;
-
-		for (const server of this.servers.values()) {
-			server.update();
-			server.observedPeerConnections.forEach((pc) => clientIds.add(pc.client.clientId));
-		}
-
-		this.numberOfClients = clientIds.size;
-	}
-
-	public addPeerConnection(peerConnection: ObservedPeerConnection) {
-		const turnPairs = peerConnection.selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === 'relay' && pair.getRemoteCandidate()?.url?.startsWith('turn:'));
-
-		if (turnPairs.length !== 1) {
-			return (logger.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), undefined);
-		}
-
-		const candidatePair = turnPairs[0];
-		const rawUrl = candidatePair.getRemoteCandidate()?.url;
-
-		if (!rawUrl) {
-			return (logger.warn(`No remote candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), undefined);
-		}
-
-		const turnUrl = new URL(rawUrl);
-		const turnServerUrl = `${turnUrl.protocol}//${turnUrl.hostname}:${turnUrl.port}`;
-		let turnServer = this.servers.get(turnServerUrl);
-        
-		if (!turnServer) {
-			turnServer = new ObservedTurnServer(turnServerUrl, this);
-		}
-
-		return turnServer;
-	}
-
-	public removePeerConnection(peerConnection: ObservedPeerConnection) {
-		for (const turnServer of this.servers.values()) {
-			turnServer.observedPeerConnections.delete(peerConnection.peerConnectionId);
-		}
-	}
-
-}

package/src/ObservedTurnServer.ts

@@ -1,72 +0,0 @@
-import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { ObservedTURN } from './ObservedTURN';
-
-export class ObservedTurnServer {
-	public totalBytesSent = 0;
-	public totalBytesReceived = 0;
-	public totalPacketsSent = 0;
-	public totalPacketsReceived = 0;
-
-	public packetsSentPerSecond = 0;
-	public packetsReceivedPerSecond = 0;
-	public outboundBitrate = 0;
-	public inboundBitrate = 0;
-
-	public deltaBytesSent = 0;
-	public deltaBytesReceived = 0;
-	public deltaPacketsSent = 0;
-	public deltaPacketsReceived = 0;
-    
-	public readonly observedPeerConnections = new Map<string, ObservedPeerConnection>(); 
-
-	public updated = Date.now();
-
-	public constructor(
-		public readonly url: string,
-		public readonly observedTURN: ObservedTURN,
-	) {
-
-	}
-
-	public updateTurnUsage(...selectedcandidatepairs: ObservedIceCandidatePair[]) {
-		for (const selectedcandidatepair of selectedcandidatepairs) {
-			this.deltaBytesReceived += selectedcandidatepair.deltaBytesReceived;
-			this.deltaBytesSent += selectedcandidatepair.deltaBytesSent;
-			this.deltaPacketsReceived += selectedcandidatepair.deltaPacketsReceived;
-			this.deltaPacketsSent += selectedcandidatepair.deltaPacketsSent;
-		}
-	}
-
-	public update() {
-		const now = Date.now();
-		const deltaInS = (now - this.updated) / 1000;
-        
-		this.packetsSentPerSecond = this.deltaPacketsSent / deltaInS;
-		this.packetsReceivedPerSecond = this.deltaPacketsReceived / deltaInS;   
-		this.outboundBitrate = (this.deltaBytesReceived * 8) / deltaInS;
-		this.inboundBitrate = (this.deltaBytesSent * 8) / deltaInS;
-        
-		this.totalBytesSent += this.deltaBytesSent;
-		this.totalBytesReceived += this.deltaBytesReceived;
-		this.totalPacketsSent += this.deltaPacketsSent;
-		this.totalPacketsReceived += this.deltaPacketsReceived;
-		
-		this.observedTURN.totalBytesSent += this.deltaBytesSent;
-		this.observedTURN.totalBytesReceived += this.deltaBytesReceived;
-		this.observedTURN.totalPacketsSent += this.deltaPacketsSent;
-		this.observedTURN.totalPacketsReceived += this.deltaPacketsReceived;
-        
-		this.observedTURN.inboundBitrate += this.inboundBitrate;
-		this.observedTURN.outboundBitrate += this.outboundBitrate;
-		this.observedTURN.packetsReceivedPerSecond += this.packetsReceivedPerSecond;
-		this.observedTURN.packetsSentPerSecond += this.packetsSentPerSecond;
-        
-		this.deltaBytesSent = 0;
-		this.deltaBytesReceived = 0;
-		this.deltaPacketsSent = 0;
-		this.deltaPacketsReceived = 0;
-
-		this.updated = now;
-	}
-}

package/src/Observer.ts

@@ -1,239 +0,0 @@
-import { createLogger } from './common/logger';
-import { ObservedCall, ObservedCallSettings } from './ObservedCall';
-import { EventEmitter } from 'events';
-import { ClientEvent, ClientMetaData, ClientIssue, ExtensionStat, ClientSample } from './schema/ClientSample';
-import { ObservedClient } from './ObservedClient';
-import { ObservedTURN } from './ObservedTURN';
-import { Detectors } from './detectors/Detectors';
-import { Updater } from './updaters/Updater';
-import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
-import { OnAllCallObserverUpdater } from './updaters/OnAllCallObserverUpdater_';
-import { OnAnyCallObserverUpdater } from './updaters/OnAnyCallObserverUpdater_';
-
-const logger = createLogger('Observer');
-
-export type ObserverEvents = {
-	'client-event': [ObservedClient, ClientEvent];
-	'call-updated': [ObservedCall],
-	'client-issue': [ObservedClient, ClientIssue],
-	'client-metadata': [ObservedClient, ClientMetaData],
-	'client-extension-stats': [ObservedClient, ExtensionStat],
-	'newcall': [ObservedCall],
-	'update': [],
-	'close': [],
-}
-
-export type ObserverConfig = {
-	updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'update-on-interval',
-	updateIntervalInMs?: number,
-	defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'],
-	defaultCallUpdateIntervalInMs?: number,
-}
-
-export declare interface Observer {
-	on<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
-	off<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
-	once<U extends keyof ObserverEvents>(event: U, listener: (...args: ObserverEvents[U]) => void): this;
-	emit<U extends keyof ObserverEvents>(event: U, ...args: ObserverEvents[U]): boolean;
-}
-
-export class Observer extends EventEmitter {
-	public readonly detectors: Detectors;
-
-	public readonly observedTURN = new ObservedTURN();
-	public readonly observedCalls = new Map<string, ObservedCall>();
-	public updater?: Updater;
-	
-	public closed = false;
-
-	public totalAddedCall = 0;
-	public totalRemovedCall = 0;
-	public totalRttLt50Measurements = 0;
-	public totalRttLt150Measurements = 0;
-	public totalRttLt300Measurements = 0;
-	public totalRttGtOrEq300Measurements = 0;
-	public totalClientIssues = 0;
-
-	public numberOfClientsUsingTurn = 0;
-	public numberOfClients = 0;
-	public numberOfInboundRtpStreams = 0;
-	public numberOfOutboundRtpStreams = 0;
-	public numberOfDataChannels = 0;
-	public numberOfPeerConnections = 0;
-	
-	public get numberOfCalls() {
-		return this.observedCalls.size;
-	}
-
-	private _timer?: ReturnType<typeof setInterval>;
-
-	public constructor(public readonly config: ObserverConfig = {
-		updatePolicy: 'update-when-all-call-updated',
-		updateIntervalInMs: undefined,
-	}) {
-		super();
-		this.setMaxListeners(Infinity);
-		this.update = this.update.bind(this);
-
-		if (this.config.updateIntervalInMs) {
-			if (this.config.updatePolicy && this.config.updatePolicy !== 'update-on-interval') {
-				throw new Error('update policy must be update-on-interval if updateIntervalInMs is set in config');
-			}
-			this._timer = setInterval(this.update.bind(this), this.config.updateIntervalInMs);
-		}
-
-		if (this.config.updateIntervalInMs) {
-			if (this.config.updatePolicy !== 'update-on-interval') {
-				throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
-			}
-		}
-		switch (this.config.updatePolicy) {
-			case 'update-on-any-call-updated':
-				this.updater = new OnAllCallObserverUpdater(this);	
-				break;
-			case 'update-when-all-call-updated':
-				this.updater = new OnAnyCallObserverUpdater(this);	
-				break;
-			case 'update-on-interval': 
-				if (!this.config.updateIntervalInMs) {
-					throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
-				}
-				this.updater = new OnIntervalUpdater(
-					this.config.updateIntervalInMs,
-					this.update.bind(this),
-				);
-				break;
-		}
-		
-		this.detectors = new Detectors();
-	}
-
-	public getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined {
-		if (this.closed || !this.observedCalls.has(callId)) return;
-		
-		return this.observedCalls.get(callId) as ObservedCall<T>;
-	}
-
-	public createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(
-		settings: ObservedCallSettings<T>
-	): ObservedCall<T> {
-		if (this.closed) {
-			throw new Error('Attempted to create a call source on a closed observer');
-		}
-		if (!settings.updatePolicy) {
-			settings.updatePolicy = this.config.defaultCallUpdatePolicy;
-			settings.updateIntervalInMs = this.config.defaultCallUpdateIntervalInMs;
-		}
-
-		const observedCall = new ObservedCall(settings, this);
-		const onCallUpdated = () => this._onObservedCallUpdated(observedCall);
-
-		if (this.observedCalls.has(observedCall.callId)) throw new Error(`Observed Call with id ${observedCall.callId} already exists`);
-
-		observedCall.once('close', () => {
-			this.observedCalls.delete(observedCall.callId);
-			observedCall.off('update', onCallUpdated);
-			++this.totalRemovedCall;
-		});
-
-		this.observedCalls.set(observedCall.callId, observedCall);
-		observedCall.on('update', onCallUpdated);
-		++this.totalAddedCall;
-
-		this.emit('newcall', observedCall);
-		
-		return observedCall;
-	}
-
-	public close() {
-		if (this.closed) {
-			return logger.debug('Attempted to close twice');
-		}
-		this.closed = true;
-		clearInterval(this._timer);
-		this._timer = undefined;
-
-		this.observedCalls.forEach((call) => call.close());
-		
-		this.emit('close');
-	}
-
-	public accept(sample: ClientSample) {
-		if (this.closed) return;
-		if (!sample.callId) return logger.warn('Received sample without callId. %o', sample);
-		if (!sample.clientId) return logger.warn('Received sample without clientId %o', sample);
-
-		const call = this.getObservedCall(sample.callId) ?? this.createObservedCall({
-			callId: sample.callId,
-			updateIntervalInMs: this.config.defaultCallUpdateIntervalInMs,
-			updatePolicy: this.config.defaultCallUpdatePolicy,
-		});
-
-		const client = call.getObservedClient(sample.clientId) ?? call.createObservedClient({
-			clientId: sample.clientId,
-		});
-
-		client.accept(sample);
-	}
-
-	public update() {
-		if (this.closed) {
-			return;
-		}
-
-		this.numberOfInboundRtpStreams = 0;
-		this.numberOfOutboundRtpStreams = 0;
-		this.numberOfPeerConnections = 0;
-		this.numberOfDataChannels = 0;
-		this.numberOfClients = 0;
-		this.numberOfClientsUsingTurn = 0;
-
-		for (const call of this.observedCalls.values()) {
-			this.numberOfInboundRtpStreams += call.numberOfInboundRtpStreams;
-			this.numberOfOutboundRtpStreams += call.numberOfOutboundRtpStreams;
-			this.numberOfPeerConnections += call.numberOfPeerConnections;
-			this.numberOfDataChannels += call.numberOfDataChannels;
-			this.numberOfClients += call.numberOfClients;
-			this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
-		}
-
-		this.observedTURN.update();
-
-		this.emit('update');
-	}
-
-	private _onObservedCallUpdated(call: ObservedCall) {
-		this.totalRttLt50Measurements += call.deltaRttLt50Measurements;
-		this.totalRttLt150Measurements += call.deltaRttLt150Measurements;
-		this.totalRttLt300Measurements += call.deltaRttLt300Measurements;
-		this.totalRttGtOrEq300Measurements += call.deltaRttGtOrEq300Measurements;
-		this.totalClientIssues += call.deltaNumberOfIssues;
-	}
-
-	// public resetSummaryMetrics() {
-	// 	this.totalAddedCall = 0;
-	// 	this.totalRemovedCall = 0;
-	// 	this.totalRttLt50Measurements = 0;
-	// 	this.totalRttLt150Measurements = 0;
-	// 	this.totalRttLt300Measurements = 0;
-	// 	this.totalRttGtOrEq300Measurements = 0;
-	// 	this.totalClientIssues = 0;
-	// }
-
-	// public createSummary(): ObserverSummary {
-	// 	return {
-	// 		totalAddedCall: this.totalAddedCall,
-	// 		totalRemovedCall: this.totalRemovedCall,
-	// 		totalRttLt50Measurements: this.totalRttLt50Measurements,
-	// 		totalRttLt150Measurements: this.totalRttLt150Measurements,
-	// 		totalRttLt300Measurements: this.totalRttLt300Measurements,
-	// 		totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
-
-	// 		totalClientIssues: this.totalClientIssues,
-	// 		currentActiveCalls: this.observedCalls.size,
-	// 		currentNumberOfClients: this.numberOfClients,
-	// 		currentNumberOfClientsUsingTURN: this.numberOfClientsUsedTurn,
-	// 	};
-	// }
-
-}

package/src/ObserverSummary.ts

@@ -1,15 +0,0 @@
-export type ObserverSummary = {
-	currentActiveCalls: number;
-	currentNumberOfClientsUsingTURN: number;
-	currentNumberOfClients: number;	
-
-	totalAddedCall: number;
-	totalRemovedCall: number;
-
-	totalRttLt50Measurements: number,
-	totalRttLt150Measurements: number,
-	totalRttLt300Measurements: number,
-	totalRttGtOrEq300Measurements: number,
-
-	totalClientIssues: number,
-}

package/src/common/Middleware.ts

@@ -1,84 +0,0 @@
-export type Middleware<T> = (
-	input: T,
-	next: (nextInput: T) => void
-) => void;
-
-export interface Processor<T> {
-	finalCallback?: Callback<T>;
-	process(value: T): void;
-	addMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
-	removeMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
-}
-
-type Callback<T> = (input: T) => void;
-
-class Executor<T> {
-	public done = false;
-	private index = 0;
-	private prevIndex = -1;
-
-	constructor(
-		private readonly stack: Middleware<T>[], 
-		private readonly finalCallback?: Callback<T>
-	) {
-	}
-
-	// Executes the middleware stack
-	public execute(input: T): void {
-		if (this.index <= this.prevIndex) {
-			throw new Error('Middleware must call next() only once!');
-		} else if (this.done) {
-			throw new Error('Middleware stack has already been executed!');
-		}
-
-		this.prevIndex = this.index;
-
-		const middleware = this.stack[this.index];
-
-		this.index++;
-
-		if (middleware) {
-			return middleware(input, (nextInput: T) => this.execute(nextInput));
-		}
-
-		this.done = true;
-		this.finalCallback?.(input);
-	}
-}
-
-export class MiddlewareProcessor<T> implements Processor<T> {
-	private stack: Middleware<T>[] = [];
-	public finalCallback?: Callback<T>;
-
-	public addMiddleware(...middlewares: Middleware<T>[]): Processor<T> {
-		if (middlewares && middlewares.length > 0) {
-			this.stack.push(...middlewares);
-		}
-		
-		return this;
-	}
-
-	public removeMiddleware(...middlewares: Middleware<T>[]): Processor<T> {
-		if (middlewares && middlewares.length > 0) {
-			for (const middleware of middlewares) {
-				const index = this.stack.indexOf(middleware);
-
-				if (index >= 0) {
-					this.stack.splice(index, 1);
-				}
-			}
-		}
-
-		return this;
-	}
-
-	public process(value: T): void {
-		if (this.stack.length === 0) {
-			return this.finalCallback?.(value);
-		}
-
-		const executor = new Executor(this.stack, this.finalCallback);
-
-		executor.execute(value);
-	}
-}

package/src/common/SingleExecutor.ts

@@ -1,36 +0,0 @@
-export type SingleExecutor = ReturnType<typeof createSingleExecutor>;
-
-export function createSingleExecutor() {
-	let semaphore = 1;
-	const tasks: (() => Promise<unknown>)[] = [];
-
-	const execute = <T = unknown>(task: () => Promise<T>) => {
-		return new Promise<T>((resolve, reject) => {
-			tasks.push(() => task().then(resolve)
-				.catch(reject));
-			run();
-		});
-	};
-
-	const run = () => {
-		if (semaphore < 1) return;
-
-		const task = tasks.shift();
-
-		if (!task) return;
-
-		const postProcess = () => {
-			++semaphore;
-			run();
-		};
-
-		--semaphore;
-
-		task()
-			.then(postProcess)
-			.catch(postProcess);
-	
-	};
-
-	return execute;
-}