@observertc/observer-js 0.9.21-beta → 0.9.23-beta

package/src/samples/ObservedSfus.ts

@@ -1,5 +1,4 @@
 import { iteratorConverter } from '../common/utils';
-import { ObservedCall, ObservedCallBuilder } from './ObservedCall';
 import { ObservedSfu, ObservedSfuBuilder } from './ObservedSfu';
 
 export interface ObservedSfus {
@@ -23,25 +22,28 @@ export class ObservedSfusBuilder {
 		configSupplier: () => ConstructorParameters<typeof ObservedSfuBuilder>[0]
 	) {
 		let result = this._builders.get(sfuId);
+
 		if (!result) {
 			const config = configSupplier();
+
 			result = new ObservedSfuBuilder(config);
 			this._builders.set(sfuId, result);
 		}
+		
 		return result;
 	}
 
 	public build(): ObservedSfus {
 		const observedSfus = new Map<string, ObservedSfu>();
 
-		const sfuIdsGenerator = function* () {
+		const sfuIdsGenerator = function *() {
 			for (const observedSfu of observedSfus.values()) {
 				yield observedSfu.sfuId;
 			}
 		};
 		const sfuIds = () => iteratorConverter<string>(sfuIdsGenerator());
 
-		const sfuTransportIdsGenerator = function* () {
+		const sfuTransportIdsGenerator = function *() {
 			for (const observedSfu of observedSfus.values()) {
 				for (const observedTransport of observedSfu.observedSfuTransports()) {
 					yield observedTransport.transportId;
@@ -50,7 +52,7 @@ export class ObservedSfusBuilder {
 		};
 		const sfuTransportIds = () => iteratorConverter<string>(sfuTransportIdsGenerator());
 
-		const sfuInboundRtpPadIdsGenerator = function* () {
+		const sfuInboundRtpPadIdsGenerator = function *() {
 			for (const observedSfu of observedSfus.values()) {
 				for (const observedTransport of observedSfu.observedSfuTransports()) {
 					for (const sfuInboundRtpPad of observedTransport.inboundRtpPads()) {
@@ -61,7 +63,7 @@ export class ObservedSfusBuilder {
 		};
 		const sfuInboundRtpPadIds = () => iteratorConverter<string>(sfuInboundRtpPadIdsGenerator());
 
-		const sfuOutboundRtpPadIdsGenerator = function* () {
+		const sfuOutboundRtpPadIdsGenerator = function *() {
 			for (const observedSfu of observedSfus.values()) {
 				for (const observedTransport of observedSfu.observedSfuTransports()) {
 					for (const sfuOutboundRtpPad of observedTransport.outboundRtpPads()) {
@@ -80,11 +82,14 @@ export class ObservedSfusBuilder {
 			observedSfus: () => observedSfus.values(),
 			getObservedSfu: (sfuId) => observedSfus.get(sfuId),
 		};
+
 		for (const builder of this._builders.values()) {
 			const observedSfu = builder.build();
+
 			observedSfus.set(observedSfu.sfuId, observedSfu);
 		}
 		this._builders.clear();
+		
 		return result;
 	}
 }

package/src/sinks/ObserverSink.ts

@@ -121,19 +121,21 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 		this._processor = createProcessor();
 	}
 
-
 	public on<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this {
 		this._emitter.addListener(event, listener);
+		
 		return this;
 	}
 
 	public off<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this {
 		this._emitter.removeListener(event, listener);
+		
 		return this;
 	}
 
 	public once<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this {
 		this._emitter.once(event, listener);
+		
 		return this;
 	}
 
@@ -230,12 +232,14 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 			await process(context);
 			if (next) await next(context);
 		};
+
 		this._customProcesses.set(process, middleware);
 		this._processor.addMiddleware(middleware);
 	}
 
 	public removeProcess(process: ObserverSinkProcess) {
 		const middleware = this._customProcesses.get(process);
+
 		if (!middleware) {
 			return;
 		}
@@ -249,7 +253,7 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 			return;
 		}
 		if (this._processes.has(this._index)) {
-			logger.warn(`The sink process has been called while the previous process has not yet completed. This may indicate that the observer is attempting to process more reports than it can handle.`);
+			logger.warn('The sink process has been called while the previous process has not yet completed. This may indicate that the observer is attempting to process more reports than it can handle.');
 		}
 
 		const actualBlockingPoint = this._processes.get(this._index) ?? Promise.resolve();
@@ -270,7 +274,9 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 				resolve();
 			});
 		});
+
 		this._processes.set(index, nextBlockingPoint);
+		
 		return result;
 	}
 
@@ -284,9 +290,10 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 		};
 		
 		const context = this._createObserverSinkContext();
-		this._process(context).catch(err => {
-			logger.error(`Error occurred while processing reports`, err);
-		})
+
+		this._process(context).catch((err) => {
+			logger.error('Error occurred while processing reports', err);
+		});
 
 		checkAndEmit('call-event', this._callEventReports);
 		this._callEventReports = [];
@@ -349,45 +356,45 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 		return this._emitter.emit(event, reports);
 	}
 
-	private  _createObserverSinkContext(): ObserverSinkContext {
-		const callEventReports = [...this._callEventReports];
-		const callMetaReports = [...this._callMetaReports];
-		const clientDataChannelReports = [...this._clientDataChannelReports];
-		const clientExtensionReports = [...this._clientExtensionReports];
-		const iceCandidatePairReports = [...this._iceCandidatePairReports];
-		const inboundAudioTrackReports = [...this._inboundAudioTrackReports];
-		const inboundVideoTrackReports = [...this._inboundVideoTrackReports];
-		const peerConnectionTransportReports = [...this._peerConnectionTransportReports];
-		const observerEventReports = [...this._observerEventReports];
-		const outboundAudioTrackReports = [...this._outboundAudioTrackReports];
-		const outboundVideoTrackReports = [...this._outboundVideoTrackReports];
-		const sfuEventReports = [...this._sfuEventReports];
-		const sfuExtensionReports = [...this._sfuExtensionReports];
-		const sfuInboundRtpPadReports = [...this._sfuInboundRtpPadReports];
-		const sfuOutboundRtpPadReports = [...this._sfuOutboundRtpPadReports];
-		const sfuSctpStreamReports = [...this._sfuSctpStreamReports];
-		const sfuTransportReports = [...this._sfuTransportReports];
-		const sfuMetaReports = [...this._sfuMetaReports];
-	  
+	private _createObserverSinkContext(): ObserverSinkContext {
+		const callEventReports = [ ...this._callEventReports ];
+		const callMetaReports = [ ...this._callMetaReports ];
+		const clientDataChannelReports = [ ...this._clientDataChannelReports ];
+		const clientExtensionReports = [ ...this._clientExtensionReports ];
+		const iceCandidatePairReports = [ ...this._iceCandidatePairReports ];
+		const inboundAudioTrackReports = [ ...this._inboundAudioTrackReports ];
+		const inboundVideoTrackReports = [ ...this._inboundVideoTrackReports ];
+		const peerConnectionTransportReports = [ ...this._peerConnectionTransportReports ];
+		const observerEventReports = [ ...this._observerEventReports ];
+		const outboundAudioTrackReports = [ ...this._outboundAudioTrackReports ];
+		const outboundVideoTrackReports = [ ...this._outboundVideoTrackReports ];
+		const sfuEventReports = [ ...this._sfuEventReports ];
+		const sfuExtensionReports = [ ...this._sfuExtensionReports ];
+		const sfuInboundRtpPadReports = [ ...this._sfuInboundRtpPadReports ];
+		const sfuOutboundRtpPadReports = [ ...this._sfuOutboundRtpPadReports ];
+		const sfuSctpStreamReports = [ ...this._sfuSctpStreamReports ];
+		const sfuTransportReports = [ ...this._sfuTransportReports ];
+		const sfuMetaReports = [ ...this._sfuMetaReports ];
+
 		return {
-		  callEventReports,
-		  callMetaReports,
-		  clientDataChannelReports,
-		  clientExtensionReports,
-		  iceCandidatePairReports,
-		  inboundAudioTrackReports,
-		  inboundVideoTrackReports,
-		  peerConnectionTransportReports,
-		  observerEventReports,
-		  outboundAudioTrackReports,
-		  outboundVideoTrackReports,
-		  sfuEventReports,
-		  sfuExtensionReports,
-		  sfuInboundRtpPadReports,
-		  sfuOutboundRtpPadReports,
-		  sfuSctpStreamReports,
-		  sfuTransportReports,
-		  sfuMetaReports,
+			callEventReports,
+			callMetaReports,
+			clientDataChannelReports,
+			clientExtensionReports,
+			iceCandidatePairReports,
+			inboundAudioTrackReports,
+			inboundVideoTrackReports,
+			peerConnectionTransportReports,
+			observerEventReports,
+			outboundAudioTrackReports,
+			outboundVideoTrackReports,
+			sfuEventReports,
+			sfuExtensionReports,
+			sfuInboundRtpPadReports,
+			sfuOutboundRtpPadReports,
+			sfuSctpStreamReports,
+			sfuTransportReports,
+			sfuMetaReports,
 		};
-	  }
+	}
 }

package/src/sinks/callEventReports.ts

@@ -1,6 +1,6 @@
 import { CallEventReport } from '@observertc/report-schemas-js';
-import { stringify } from 'uuid';
 
+// eslint-disable-next-line no-shadow
 export enum CallEventType {
 	CALL_STARTED = 'CALL_STARTED',
 	CALL_ENDED = 'CALL_ENDED',

package/src/sources/ObservedCallSource.ts

@@ -1,20 +1,23 @@
-import { ClientSample } from '@observertc/sample-schemas-js';
 import { PartialBy } from '../common/utils';
 import { ObservedClientSource, ObservedClientSourceConfig } from './ObservedClientSource';
 
-export type ObservedCallSourceConfig = {
+export type ObservedCallSourceConfig<T extends Record<string, unknown>> = {
+	readonly appData: T
 	readonly serviceId: string;
 	readonly mediaUnitId: string;
 	readonly roomId: string;
 	readonly callId: string;
 };
 
-export interface ObservedCallSource extends ObservedCallSourceConfig {
+export interface ObservedCallSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedCallSourceConfig<T> {
 	readonly closed: boolean;
+	readonly clients: IterableIterator<ObservedClientSource>;
 
-	createClientSource(
-		context: PartialBy<ObservedClientSourceConfig, 'joined' | 'mediaUnitId' | 'serviceId' | 'callId' | 'roomId'>
-	): ObservedClientSource;
+	getClientSource<U extends Record<string, unknown>>(clientId: string): ObservedClientSource<U> | undefined;
+
+	createClientSource<U extends Record<string, unknown> = Record<string, unknown>>(
+		context: PartialBy<ObservedClientSourceConfig<U>, 'joined' | 'mediaUnitId' | 'serviceId' | 'callId' | 'roomId'>
+	): ObservedClientSource<U>;
 
 	// automatically close every
 	close(): void;

package/src/sources/ObservedClientSource.ts

@@ -1,6 +1,7 @@
 import { ClientSample } from '@observertc/sample-schemas-js';
 
-export type ObservedClientSourceConfig = {
+export type ObservedClientSourceConfig<T extends Record<string, unknown> = Record<string, unknown>> = {
+	readonly appData: T;
 	readonly serviceId: string;
 	readonly mediaUnitId: string;
 	readonly roomId: string;
@@ -13,7 +14,7 @@ export type ObservedClientSourceConfig = {
 	timeZoneId?: string;
 };
 
-export interface ObservedClientSource extends ObservedClientSourceConfig {
+export interface ObservedClientSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedClientSourceConfig<T> {
 	readonly closed: boolean;
 
 	accept(...samples: ClientSample[]): void;

package/src/sources/ObservedSfuSource.ts

@@ -1,6 +1,7 @@
-import { ClientSample, SfuSample } from '@observertc/sample-schemas-js';
+import { SfuSample } from '@observertc/sample-schemas-js';
 
-export type ObservedSfuSourceConfig = {
+export type ObservedSfuSourceConfig<T extends Record<string, unknown> = Record<string, unknown>> = {
+	readonly appData: T;
 	readonly serviceId: string;
 	readonly mediaUnitId: string;
 	readonly sfuId: string;
@@ -9,15 +10,10 @@ export type ObservedSfuSourceConfig = {
 	timeZoneId?: string;
 };
 
-export interface ObservedSfuSource extends ObservedSfuSourceConfig {
+export interface ObservedSfuSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedSfuSourceConfig<T> {
 	readonly closed: boolean;
 
 	accept(...samples: SfuSample[]): void;
 
-	// when you close this, client is disposed. so this triggers the client to dispose
-	// therefore this triggers the call to be disposed
-	// peer connections, and tracks the creation is evented by the client,
-	// the close of those object is evented by the observer or closing this
-	// call the close of this is mandatory, as only this closes the client inside the observer
 	close(): void;
 }

package/src/sources/Sources.ts

@@ -4,9 +4,9 @@ import { ObservedClientSource, ObservedClientSourceConfig } from './ObservedClie
 import { EventEmitter } from 'events';
 import { createLogger } from '../common/logger';
 import { PartialBy } from '../common/utils';
-import { ObservedCallSource, ObservedCallSourceConfig } from './ObservedCallSource';
 import { ObservedSfuSourceConfig, ObservedSfuSource } from './ObservedSfuSource';
 import { ObservedSfus, ObservedSfusBuilder } from '../samples/ObservedSfus';
+import { ObservedCallSource, ObservedCallSourceConfig } from './ObservedCallSource';
 
 const logger = createLogger('Sources');
 
@@ -30,7 +30,8 @@ export type SourcesEvents = {
 export class Sources {
 	
 	private readonly _warnFlags = { autoEmitButEmitSamplesInvoked: false };
-	private readonly _clientSources = new Map<string, ObservedClientSource>();
+	private readonly _callSources = new Map<string, ObservedCallSource>();
+	// private readonly _clientSources = new Map<string, ObservedClientSource>();
 	private readonly _sfuSources = new Map<string, ObservedSfuSource>();
 	private readonly _emitter = new EventEmitter();
 	
@@ -41,13 +42,27 @@ export class Sources {
 
 	public constructor(public readonly config: SourcesConfig) {}
 
+	public getCallSource<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCallSource<T> | undefined {
+		if (!this._callSources.has(callId)) return;
+		
+		return this._callSources.get(callId) as ObservedCallSource<T>;
+	}
+
+	public getSfuSource<T extends Record<string, unknown> = Record<string, unknown>>(sfuId: string) {
+		if (!this._sfuSources.has(sfuId)) return;
+
+		return this._sfuSources.get(sfuId) as ObservedSfuSource<T>;
+	}
+
 	public on<K extends keyof SourcesEvents>(event: K, listener: (data: SourcesEvents[K]) => void): this {
 		this._emitter.addListener(event, listener);
+		
 		return this;
 	}
 
 	public off<K extends keyof SourcesEvents>(event: K, listener: (data: SourcesEvents[K]) => void): this {
 		this._emitter.removeListener(event, listener);
+		
 		return this;
 	}
 
@@ -55,16 +70,86 @@ export class Sources {
 		return this._emitter.emit(event, data);
 	}
 
-	public createClientSource(config: PartialBy<ObservedClientSourceConfig, 'joined'>): ObservedClientSource {
-		const existingClientSource = this._clientSources.get(config.clientId);
-		if (existingClientSource) {
-			logger.warn(`Attempted to add a ClientSource for client ${config.clientId} twice`);
-			return existingClientSource;
+	public createCallSource<T extends Record<string, unknown> = Record<string, unknown>>(
+		config: ObservedCallSourceConfig<T>
+	): ObservedCallSource<T> {
+		let closed = false;
+		const { 
+			serviceId,
+			mediaUnitId,
+			appData, 
+			...callConfig 
+		} = config;
+		const clientSources = new Map<string, ObservedClientSource>();
+		const callSource: ObservedCallSource<T> = {
+			...callConfig,
+			appData,
+			serviceId,
+			mediaUnitId,
+			get clients() {
+				return clientSources.values();
+			},
+
+			getClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(clientId: string) => {
+				if (!clientSources.has(clientId)) return;
+				else return clientSources.get(clientId) as ObservedClientSource<U>;
+			},
+
+			createClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(context: ObservedClientSourceConfig<U>) => {
+				const existingClientSource = clientSources.get(context.clientId);
+
+				if (existingClientSource) return existingClientSource as ObservedClientSource<U>;
+				
+				const { appData: clientAppData, ...clientConfig } = context;
+				const clientSource = this._createClientSource<U>({
+					...callConfig,
+					...clientConfig,
+					appData: clientAppData,
+					serviceId,
+					mediaUnitId,
+				});
+				const closeClientSource = clientSource.close;
+
+				clientSource.close = () => {
+					closeClientSource();
+					clientSources.delete(context.clientId);
+				};
+				clientSources.set(context.clientId, clientSource);
+				
+				return clientSource as ObservedClientSource<U>;
+			},
+			close: () => {
+				if (closed) {
+					return;
+				}
+				for (const clientSource of clientSources.values()) {
+					clientSource.close();
+				}
+				clientSources.clear();
+				this._callSources.delete(config.callId);
+				closed = true;
+			},
+			closed,
+		};
+		
+		if (this._callSources.size < 1) {
+			this._resetTimer();
 		}
+		this._callSources.set(config.callId, callSource);
+		
+		return callSource;
+	}
+
+	private _createClientSource<T extends Record<string, unknown> = Record<string, unknown>>(config: PartialBy<ObservedClientSourceConfig<T>, 'joined'>): ObservedClientSource<T> {
 		let closed = false;
-		// config.joined = config.joined ?? Date.now();
-		const source: ObservedClientSource = {
-			...config,
+		const {
+			appData,
+			...clientConfig
+		} = config;
+
+		const source: ObservedClientSource<T> = {
+			...clientConfig,
+			appData,
 			joined: config.joined ?? Date.now(),
 
 			accept: (...samples: ClientSample[]) => {
@@ -92,23 +177,20 @@ export class Sources {
 					return;
 				}
 				closed = true;
-				this._clientSources.delete(config.clientId);
 				this._emit('removed-client-source', source);
 			},
 			closed,
 		};
-		if (this._clientSources.size < 1) {
-			this._resetTimer();
-		}
-		this._clientSources.set(config.clientId, source);
+
 		this._emit('added-client-source', source);
+		
 		return source;
 	}
 
-	public createSfuSource(config: PartialBy<ObservedSfuSourceConfig, 'joined'>): ObservedSfuSource {
+	public createSfuSource<T extends Record<string, unknown> = Record<string, unknown>>(config: PartialBy<ObservedSfuSourceConfig<T>, 'joined'>): ObservedSfuSource {
 		const existingSfuSource = this._sfuSources.get(config.sfuId);
+
 		if (existingSfuSource) {
-			logger.warn(`Attempted to add a SfuSource for sfu ${config.sfuId} twice`);
 			return existingSfuSource;
 		}
 		let closed = false;
@@ -142,11 +224,13 @@ export class Sources {
 			},
 			closed,
 		};
+
 		if (this._sfuSources.size < 1) {
 			this._resetTimer();
 		}
 		this._sfuSources.set(config.sfuId, source);
 		this._emit('added-sfu-source', source);
+		
 		return source;
 	}
 
@@ -174,8 +258,10 @@ export class Sources {
 	private _emitSamples() {
 		this._resetTimer();
 		const observedCalls = this._observedCallsBuilder.build();
+
 		this._observedCallsBuilder = new ObservedCallsBuilder();
 		const observedSfus = this._observedSfusBuilder.build();
+
 		this._observedSfusBuilder = new ObservedSfusBuilder();
 		this._emit('observed-samples', {
 			observedCalls,
@@ -199,11 +285,10 @@ export class Sources {
 	}
 
 	public close() {
-		for (const clientSource of this._clientSources.values()) {
-			if (!clientSource.closed) {
-				clientSource.close();
-			}
-		}
+		[ ...this._callSources.values() ].forEach((callSource) => callSource.close());
+		[ ...this._sfuSources.values() ].forEach((sfuSource) => sfuSource.close());
+		this._callSources.clear();
+		this._sfuSources.clear();		
 		this._emitSamples();
 	}
 }

package/src/storages/ObserverStorage.ts

@@ -2,6 +2,7 @@
  * The `ObserverStorage` interface defines the methods used for managing storage of key-value pairs.
  */
 export interface ObserverStorage<K, V> {
+
 	/**
 	 * The identifier of the storage
 	 */

package/src/storages/SimpleStorage.ts

@@ -5,87 +5,110 @@ export class SimpleStorage<K, V> implements ObserverStorage<K, V> {
 
 	public constructor(public readonly id: string) {}
 
-	public async size(): Promise<number> {
-		return this._map.size;
+	public size(): Promise<number> {
+		return Promise.resolve(this._map.size);
 	}
 
-	public async clear(): Promise<void> {
+	public clear(): Promise<void> {
 		this._map.clear();
+
+		return Promise.resolve();
 	}
 
-	public async get(key: K): Promise<V | undefined> {
-		return this._map.get(key);
+	public get(key: K): Promise<V | undefined> {
+		return Promise.resolve(this._map.get(key));
 	}
 
-	public async getAll(keys: Iterable<K>): Promise<ReadonlyMap<K, V>> {
+	public getAll(keys: Iterable<K>): Promise<ReadonlyMap<K, V>> {
 		const result = new Map<K, V>();
+
 		for (const key of keys) {
 			const value = this._map.get(key);
+
 			if (value) {
 				result.set(key, value);
 			}
 		}
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
-	public async set(key: K, value: V): Promise<V | undefined> {
+	public set(key: K, value: V): Promise<V | undefined> {
 		const result = this._map.get(key);
+
 		this._map.set(key, value);
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
-	public async setAll(entries: ReadonlyMap<K, V>): Promise<ReadonlyMap<K, V>> {
+	public setAll(entries: ReadonlyMap<K, V>): Promise<ReadonlyMap<K, V>> {
 		const result = new Map<K, V>();
-		for (const [key, value] of entries) {
+
+		for (const [ key, value ] of entries) {
 			const oldValue = this._map.get(key);
+
 			if (oldValue) {
 				result.set(key, oldValue);
 			}
 			this._map.set(key, value);
 		}
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
-	public async insert(key: K, value: V): Promise<V | undefined> {
+	public insert(key: K, value: V): Promise<V | undefined> {
 		const result = this._map.get(key);
+
 		if (result) {
-			return result;
+			return Promise.resolve(result);
 		}
 		this._map.set(key, value);
+
+		return Promise.resolve(undefined);
 	}
 
-	public async insertAll(entries: ReadonlyMap<K, V>): Promise<ReadonlyMap<K, V>> {
+	public insertAll(entries: ReadonlyMap<K, V>): Promise<ReadonlyMap<K, V>> {
 		const result = new Map<K, V>();
-		for (const [key, value] of entries) {
+
+		for (const [ key, value ] of entries) {
 			const oldValue = this._map.get(key);
+
 			if (oldValue) {
 				result.set(key, oldValue);
 			} else {
 				this._map.set(key, value);
 			}
 		}
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
-	public async remove(key: K): Promise<V | undefined> {
+	public remove(key: K): Promise<V | undefined> {
 		const result = this._map.get(key);
+
 		this._map.delete(key);
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
-	public async removeAll(keys: Iterable<K>): Promise<ReadonlyMap<K, V>> {
+	public removeAll(keys: Iterable<K>): Promise<ReadonlyMap<K, V>> {
 		const result = new Map<K, V>();
+
 		for (const key of keys) {
 			const value = this._map.get(key);
+
 			this._map.delete(key);
 			if (value) {
 				result.set(key, value);
 			}
 		}
-		return result;
+		
+		return Promise.resolve(result);
 	}
 
 	public async *[Symbol.asyncIterator](): AsyncIterableIterator<[K, V]> {
+		await Promise.resolve();
+		
 		for (const entry of this._map.entries()) {
 			yield entry;
 		}