@fluex/fluexgl-dsp 0.4.6 → 0.4.8

package/lib/src/core/classes/AudioClip.ts

@@ -1,7 +1,7 @@
 import { v4 } from "uuid";
 import { format } from "date-fns";
 
-import { AudioClipEventMap, AudioClipEvents, AudioSourceData } from "../../typings";
+import { AudioClipEventMap, AudioClipEvents, AudioClipOnInitializeEvent, AudioSourceData } from "../../typings";
 import { Debug } from "../../utilities/debugger";
 import { Channel } from "./Channel";
 import { AudioClipPlayer } from "./AudioClipPlayer";
@@ -9,7 +9,9 @@ import { Master } from "./Master";
 import { DSP } from "../../index";
 import { ErrorCodes } from "../../console-codes";
 
-type ProgressPayload = Parameters<AudioClipEventMap["progress"]>[0];
+type OnProgressCallbackFunction = AudioClipEventMap["progress"];
+type OnInitializeCallbackFunction = AudioClipEventMap["initialize"];
+type OnPlayCallbackFunction = AudioClipEventMap["play"];
 
 export class AudioClip {
 
@@ -20,6 +22,11 @@ export class AudioClip {
     public isPlaying: boolean = false;
     public startTime: number = 0;
     public offsetAtStart: number = 0;
+    public playbackRate: number = 1;
+    public pitch: number = 0;
+
+    public minPitchSemitones: number = -24;
+    public maxPitchSemitones: number = 24;
 
     public progressUpdateSpeed: number = 20;
 
@@ -31,11 +38,14 @@ export class AudioClip {
 
     private audioBufferSourceNodes: AudioBufferSourceNode[] = [];
     private maxAudioBufferSourceNodes: number = 1;
+    private audioClipPlayers: AudioClipPlayer[] = [];
 
     private progressInterval: number | null = 0;
 
     private events: AudioClipEvents = {
-        "progress": []
+        "progress": [],
+        "initialize": [],
+        "play": []
     }
 
     constructor(public data: AudioSourceData) { }
@@ -49,6 +59,7 @@ export class AudioClip {
         const bufferSource = context.createBufferSource();
         bufferSource.buffer = this.data.audioBuffer;
         bufferSource.loop = this.loop;
+        bufferSource.playbackRate.setValueAtTime(this.playbackRate, this.context.currentTime);
 
         return bufferSource;
     }
@@ -64,54 +75,98 @@ export class AudioClip {
         node?.disconnect();
     }
 
+    private getOutputNodes(): AudioNode[] {
+
+        const nodes: AudioNode[] = [];
+
+        for (const player of this.audioClipPlayers) {
+            if (player.outputGainNode && !nodes.includes(player.outputGainNode))
+                nodes.push(player.outputGainNode);
+        }
+
+        return nodes;
+    }
+
     private rebuildNodeChain(): boolean {
 
-        if (!this.context || !this.gainNode || !this.stereoPannerNode || !this.audioClipPlayer || !this.audioClipPlayer.outputGainNode) {
-            Debug.Error("Failed to rebuild node chain, because some of the core AudioNodes are missing.");
+        if (!this.context || !this.gainNode || !this.stereoPannerNode) {
+            Debug.error("Failed to rebuild node chain, because some of the core AudioNodes are missing.");
             return false;
         }
 
-        const destination = this.audioClipPlayer.outputGainNode;
+        const destinations = this.getOutputNodes();
+
+        if (destinations.length === 0) {
+            Debug.error("Failed to rebuild node chain, because no output destinations are available.");
+            return false;
+        }
 
         this.safeDisconnect(this.gainNode);
         this.safeDisconnect(this.stereoPannerNode);
 
         this.gainNode.connect(this.stereoPannerNode);
-        this.stereoPannerNode.connect(destination);
+        for (const destination of destinations) {
+            this.stereoPannerNode.connect(destination);
+        }
 
         this.connectSourcesTo(this.gainNode);
         return true;
     }
 
-    public Initialize(audioClipPlayer: AudioClipPlayer) {
+    public initialize(audioClipPlayer: AudioClipPlayer) {
+
+        const startTimestamp: number = Date.now(),
+            self: AudioClip = this;
 
-        if (!audioClipPlayer.context) return Debug.Error("Could not initialize AudioClip, because the AudioClipPlayer somehow has no audio context.", [
+        if (!audioClipPlayer.context) return Debug.error("Could not initialize AudioClip, because the AudioClipPlayer somehow has no audio context.", [
             `AudioClipPlayer id: ${audioClipPlayer.id}`,
             `AudioClip id: ${this.id}`
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
+        if (this.context && this.context !== audioClipPlayer.context) {
+            return Debug.error("Could not initialize AudioClip, because the AudioClipPlayer does not share the same AudioContext.", [
+                `AudioClipPlayer id: ${audioClipPlayer.id}`,
+                `AudioClip id: ${this.id}`
+            ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
+        }
+
         this.audioClipPlayer = audioClipPlayer;
         this.context = audioClipPlayer.context;
 
-        this.gainNode = new GainNode(this.context);
-        this.stereoPannerNode = new StereoPannerNode(this.context);
+        if (!this.gainNode) this.gainNode = new GainNode(this.context);
+        if (!this.stereoPannerNode) this.stereoPannerNode = new StereoPannerNode(this.context);
+
+        if (!this.audioClipPlayers.includes(audioClipPlayer))
+            this.audioClipPlayers.push(audioClipPlayer);
+
+        const endTimestamp: number = Date.now(),
+            difference: number = endTimestamp - startTimestamp;
+
+        this.events.initialize.forEach(function(cb: OnInitializeCallbackFunction) {
+            cb({
+                durationOfInitialization: difference,
+                context: self.context
+            });
+        });
+
+        this.rebuildNodeChain();
     }
 
-    public Play(timestamp?: number, offset?: number) {
+    public play(timestamp?: number, offset?: number) {
 
-        if (!this.context) return Debug.Error("Could not play audio clip, because context (AudioContext) is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance, before calling .Play on this AudioClip."
+        if (!this.context) return Debug.error("Could not play audio clip, because context (AudioContext) is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance, before calling .play on this AudioClip."
         ]);
 
-        const context = this.context;
-        const self = this;
+        const context = this.context,
+            self = this;
 
         if (this.audioBufferSourceNodes.length > this.maxAudioBufferSourceNodes - 1) return null;
 
         const bufferSource: AudioBufferSourceNode | null = this.createBufferSource();
 
         if (!bufferSource) {
-            Debug.Error("Something went wrong.");
+            Debug.error("Something went wrong.");
             return null;
         }
 
@@ -121,9 +176,9 @@ export class AudioClip {
         this.offsetAtStart = actualOffset;
         this.isPlaying = true;
 
-        if (this.progressInterval) clearInterval(this.progressInterval);
+        if (this.progressInterval) window.clearInterval(this.progressInterval);
 
-        if (this.isPlaying) this.progressInterval = setInterval(function () {
+        if (this.isPlaying) this.progressInterval = window.setInterval(function () {
 
             if (!self.isPlaying) return;
 
@@ -132,7 +187,7 @@ export class AudioClip {
 
             const formattedTime = format(date, "mm:ss");
 
-            const progressPayload: ProgressPayload = {
+            const progressPayload: Parameters<AudioClipEventMap["progress"]>[0] = {
                 current: parseFloat(current.toFixed(2)),
                 startTime: self.startTime,
                 offset: self.offsetAtStart,
@@ -140,7 +195,7 @@ export class AudioClip {
                 formatted: formattedTime
             }
 
-            self.events.progress.forEach(function (cb: (event: ProgressPayload) => void) {
+            self.events.progress.forEach(function (cb: OnProgressCallbackFunction) {
                 cb(progressPayload);
             });
         }, this.progressUpdateSpeed);
@@ -163,13 +218,21 @@ export class AudioClip {
 
         bufferSource.start(timestamp ?? this.startTime, actualOffset);
 
+        this.events.play.forEach(function(cb: OnPlayCallbackFunction) {
+            cb({
+                timestamp: Date.now(),
+                audioBufferSourceNodes: self.audioBufferSourceNodes,
+                context: context,
+            })
+        });
+
         return this;
     }
 
-    public Seek(seconds: number) {
+    public seek(seconds: number) {
 
-        if (!this.context) return Debug.Error("Could not seek because the context (AudioContext) of this AudioClip is undefined.", [
-            `Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .Seek on this AudioClip.`,
+        if (!this.context) return Debug.error("Could not seek because the context (AudioContext) of this AudioClip is undefined.", [
+            `Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .seek on this AudioClip.`,
             `AudioClip id: ${this.id}`
         ]);
 
@@ -182,13 +245,13 @@ export class AudioClip {
             return this;
         }
 
-        this.Stop();
-        this.Play(undefined, clamped);
+        this.stop();
+        this.play(undefined, clamped);
 
         return this;
     }
 
-    public Stop(): AudioClip | null {
+    public stop(): AudioClip | null {
 
         this.audioBufferSourceNodes.forEach(function (node: AudioBufferSourceNode) {
             node.stop();
@@ -206,23 +269,23 @@ export class AudioClip {
         return this;
     }
 
-    public SetVolume(volume: number): AudioClip {
+    public setVolume(volume: number): AudioClip {
 
-        if (!this.context) Debug.Error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .SetVolume() on this AudioClip.",
+        if (!this.context) Debug.error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setVolume() on this AudioClip.",
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
         this.gainNode?.gain.setValueAtTime(volume, this.context?.currentTime ?? 0);
         return this;
     }
 
-    public SetPanLevel(panLevel: number): AudioClip {
+    public setPanLevel(panLevel: number): AudioClip {
 
-        if (!this.context) Debug.Error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
-            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .SetPanLevel() on this AudioClip.",
+        if (!this.context) Debug.error("Could not set volume because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setPanLevel() on this AudioClip.",
         ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
 
-        if (panLevel < -1 || panLevel > 1) Debug.Error("Could not set the pan level because it is not between -1 and 1.", [
+        if (panLevel < -1 || panLevel > 1) Debug.error("Could not set the pan level because it is not between -1 and 1.", [
             `Given value: ${panLevel}.`,
             `Accepts a value between -1 and 1. Can be a floating number.`
         ], ErrorCodes.PANNING_OUT_OF_RANGE);
@@ -231,7 +294,7 @@ export class AudioClip {
         return this;
     }
 
-    public Loop(loop?: boolean): AudioClip {
+    public setLoop(loop?: boolean): AudioClip {
 
         this.audioBufferSourceNodes.forEach(function (node: AudioBufferSourceNode) {
             node.loop = loop ?? true;
@@ -241,10 +304,10 @@ export class AudioClip {
         return this;
     }
 
-    public SetMaxAudioBufferSourceNodes(value: number): AudioClip {
+    public setMaxAudioBufferSourceNodes(value: number): AudioClip {
 
         if (!DSP.overrideMaxAudioBufferNodes) {
-            Debug.Warn("Cannot set maxAudioBufferSourceNodes because the option to override the current maximum value is disabled.", [
+            Debug.warn("Cannot set maxAudioBufferSourceNodes because the option to override the current maximum value is disabled.", [
                 "Set overrideMaxAudioBufferNodes on DSP to true, in order to override the maximum audio buffer source nodes."
             ]);
             return this;
@@ -254,7 +317,7 @@ export class AudioClip {
         return this;
     }
 
-    public DisconnectAllAudioBufferSourceNodes(): boolean {
+    public disconnectAllAudioBufferSourceNodes(): boolean {
 
         if (!this.context) return false;
 
@@ -268,25 +331,25 @@ export class AudioClip {
         return true;
     }
 
-    public AddEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
+    public addEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
 
         this.events[event].push(cb);
-        return () => this.RemoveEventListener(event, cb);
+        return () => this.removeEventListener(event, cb);
     }
 
-    public Once<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
+    public once<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): () => void {
 
         const wrapper = ((...args: unknown[]) => {
 
             // @ts-ignore
             cb(...args);
-            this.RemoveEventListener(event, wrapper as unknown as AudioClipEventMap[K]);
+            this.removeEventListener(event, wrapper as unknown as AudioClipEventMap[K]);
         }) as unknown as AudioClipEventMap[K];
 
-        return this.AddEventListener(event, wrapper);
+        return this.addEventListener(event, wrapper);
     }
 
-    public RemoveEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): AudioClip {
+    public removeEventListener<K extends keyof AudioClipEventMap>(event: K, cb: AudioClipEventMap[K]): AudioClip {
 
         const arr = this.events[event];
 
@@ -299,7 +362,7 @@ export class AudioClip {
         return this;
     }
 
-    public ClearEventListeners(event?: keyof AudioClipEventMap): AudioClip {
+    public clearEventListeners(event?: keyof AudioClipEventMap): AudioClip {
 
         if (event) {
             this.events[event].length = 0;
@@ -310,30 +373,80 @@ export class AudioClip {
         return this;
     }
 
-    public GetChannelData(channel: number = 0): Float32Array {
+    public getChannelData(channel: number = 0): Float32Array {
         return this.data.audioBuffer.getChannelData(channel);
     }
 
-    public Send(channel: Channel | Master) {
+    public send(channel: Channel | Master) {
 
-        if (!channel.audioClipPlayer) return Debug.Error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+        if (!channel.audioClipPlayer) return Debug.error("Could not send AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
             "Make sure to initialize the Channel.",
             `Channel id: ${channel.id}.`,
             `AudioClip id: ${this.id}.`
         ]);
 
-        channel.audioClipPlayer.AttachAudioClip(this);
+        channel.audioClipPlayer.attachAudioClip(this);
     }
 
-    public Unsend(channel: Channel | Master) {
+    public unsend(channel: Channel | Master) {
 
-        if (!channel.audioClipPlayer) return Debug.Error("Could not unsend AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
+        if (!channel.audioClipPlayer) return Debug.error("Could not unsend AudioClip signal to channel, because the channel's AudioClipPlayer is undefined.", [
             "Make sure to initialize the Channel.",
             `Channel id: ${channel.id}.`,
             `AudioClip id: ${this.id}.`
         ]);
 
-        channel.audioClipPlayer.DetachAudioClip(this);
+        channel.audioClipPlayer.detachAudioClip(this);
+    }
+
+    public detachFromAudioClipPlayer(audioClipPlayer: AudioClipPlayer): void {
+
+        const idx = this.audioClipPlayers.indexOf(audioClipPlayer);
+
+        if (idx === -1) return;
+
+        this.audioClipPlayers.splice(idx, 1);
+
+        if (this.audioClipPlayer === audioClipPlayer) {
+            this.audioClipPlayer = this.audioClipPlayers[0] ?? null;
+        }
+
+        if (this.audioClipPlayers.length === 0) {
+            this.stop();
+            return;
+        }
+
+        this.rebuildNodeChain();
+    }
+
+    public setPitch(semitones: number): AudioClip {
+
+        if (!this.context) Debug.error("Could not set pitch because the context (AudioContext) of this AudioClip is undefined.", [
+            "Make sure to attach this AudioClip to an AudioClipPlayer instance before calling .setPitch() on this AudioClip.",
+        ], ErrorCodes.AUDIO_CLIP_PLAYER_NO_CONTEXT);
+
+        if (semitones < this.minPitchSemitones || semitones > this.maxPitchSemitones) Debug.error("Could not set the pitch because it is not within the allowed semitone range.", [
+            `Given value: ${semitones}.`,
+            `Accepts a value between ${this.minPitchSemitones} and ${this.maxPitchSemitones} semitones.`
+        ], ErrorCodes.PITCH_OUT_OF_RANGE);
+
+        const calculatedPlaybackRate: number = Math.pow(2, semitones / 12);
+
+        for (const buffer of this.audioBufferSourceNodes) 
+            buffer.playbackRate.setValueAtTime(calculatedPlaybackRate, this.context?.currentTime ?? 0);
+
+        this.pitch = semitones;
+        this.playbackRate = calculatedPlaybackRate;
+        return this;
+    }
+
+    public resetPitch(): AudioClip {
+        return this.setPitch(0);
+    }
+
+    /** @deprecated Use {@link setPitch} instead. */
+    public setPlaybackRateInSemitones(semitones: number): AudioClip {
+        return this.setPitch(semitones);
     }
 
     public get currentPlaybackTime(): number {
@@ -355,9 +468,7 @@ export class AudioClip {
     }
 
     public get formattedDuration(): string {
-
         const date = new Date(this.duration * 1000);
-
         return format(date, "mm:ss");
     }
 
@@ -372,4 +483,4 @@ export class AudioClip {
     public get byteLength(): number {
         return this.data.arrayBuffer.byteLength;
     }
-}
+}

package/lib/src/core/classes/AudioClipPlayer.ts

@@ -22,43 +22,41 @@ export class AudioClipPlayer {
         this.outputGainNode = new GainNode(context);
     }
 
-    public AttachAudioClip(audioClip: AudioClip): void {
+    public attachAudioClip(audioClip: AudioClip): void {
 
-        if (this.audioClips.includes(audioClip)) return Debug.Error("Could not attach audio clip because it is already part of this channel", [
-            "Call .DetachAudioClip([clip AudioClip]) before attaching audio clip."
+        if (this.audioClips.includes(audioClip)) return Debug.error("Could not attach audio clip because it is already part of this channel", [
+            "Call .detachAudioClip([clip AudioClip]) before attaching audio clip."
         ], ErrorCodes.AUDIO_CLIP_ALREADY_ATTACHED);
 
-        audioClip.Initialize(this);
+        audioClip.initialize(this);
         this.audioClips.push(audioClip);
     }
 
-    public DetachAudioClip(clip: AudioClip): void {
+    public detachAudioClip(clip: AudioClip): void {
 
-        if (!this.audioClips.includes(clip)) return Debug.Error("Could not detach audio clip because it is not part of this channel", [
-            "Call .AttachAudioClip([clip AudioClip]) before detaching audio clip."
+        if (!this.audioClips.includes(clip)) return Debug.error("Could not detach audio clip because it is not part of this channel", [
+            "Call .attachAudioClip([clip AudioClip]) before detaching audio clip."
         ], ErrorCodes.AUDIO_CLIP_NOT_FOUND);
 
-        clip.Stop();
+        const idx = this.audioClips.indexOf(clip);
 
-        const self = this;
+        if (idx >= 0)
+            this.audioClips.splice(idx, 1);
 
-        this.audioClips.forEach(function (_clip: AudioClip, index: number) {
-            if (clip.id === _clip.id)
-                return self.audioClips.splice(index, 1);
-        })
+        clip.detachFromAudioClipPlayer(this);
     }
 
-    public Send(channel: Channel | Master): void {
+    public send(channel: Channel | Master): void {
 
-        if (!this.outputGainNode || !channel.input) return Debug.Error("Could not send AudioClipPlayer signal to a channel/master.");
+        if (!this.outputGainNode || !channel.input) return Debug.error("Could not send AudioClipPlayer signal to a channel/master.");
 
-        this.Unsend();
+        this.unsend();
 
         this.channel = channel;
         this.outputGainNode.connect(channel.input);
     }
 
-    public Unsend(): void {
+    public unsend(): void {
 
         if (!this.outputGainNode) return;
 
@@ -71,7 +69,7 @@ export class AudioClipPlayer {
         this.channel = null;
     }
 
-    public SetVolume(value: number): void {
+    public setVolume(value: number): void {
 
         if (!this.outputGainNode) return;
 
@@ -81,17 +79,17 @@ export class AudioClipPlayer {
         this.outputGainNode.gain.value = value;
     }
 
-    public StopAll(): void {
+    public stopAll(): void {
 
         this.audioClips.forEach(function (clip: AudioClip) {
-            clip.Stop();
+            clip.stop();
         });
     }
 
-    public Dispose(): void {
+    public dispose(): void {
 
-        this.StopAll();
-        this.Unsend();
+        this.stopAll();
+        this.unsend();
         this.outputGainNode?.disconnect();
         
         this.audioClips = [];
@@ -100,7 +98,7 @@ export class AudioClipPlayer {
         this.context = null;
     }
 
-    public SetLabel(label: string): void {
+    public setLabel(label: string): void {
         this.label = label;
     }
 

package/lib/src/core/classes/AudioDevice.ts

@@ -16,15 +16,34 @@ export class AudioDevice {
     public masterChannel: Master = new Master(this.context);
     public masterChannels: Master[] = [];
 
+    readonly sampleRate: number = this.context.sampleRate;
+    readonly baseLatency: number = this.context.baseLatency;
+    readonly outputLatency: number = this.context.outputLatency;
+    readonly state: AudioContextState = this.context.state;
+    readonly currentTime: number = this.context.currentTime;
+
+    readonly maximumFrequency: number = this.context.sampleRate / 2;
+
     constructor(public deviceInfo: MediaDeviceInfo) {};
 
-    public GetMasterChannel(): Master {
+    /**
+     * Returns the master channel associated with this audio device.
+     * The master channel is the main output channel for this audio device, and is used to control the overall volume and other properties of the audio output.
+     * @returns 
+     */
+    public getMasterChannel(): Master {
         return this.masterChannel;
     }
 
-    public SetMasterChannel(channel: Master): void {
+    /**
+     * Sets the master channel for this audio device. 
+     * The master channel is normally automatically created when the audio device is initialized, but this method allows for the master channel to be changed if needed.  
+     * @param channel 
+     * @returns 
+     */
+    public setMasterChannel(channel: Master): void {
 
-        if (channel.id === this.masterChannel.id) return Debug.Error("The provided master channel is the same as the current channel.", [
+        if (channel.id === this.masterChannel.id) return Debug.error("The provided master channel is the same as the current channel.", [
             "Provide this method with a different master channel.",
             `Received master channel ID ${channel.id}.`
         ], ErrorCodes.SAME_MASTER_CHANNEL);
@@ -32,7 +51,12 @@ export class AudioDevice {
         this.masterChannel = channel;
     }
 
-    public CreateMasterChannel(): Master {
+    /**
+     * Creates a new master channel based on the this audio device's audio context, and adds it to the master channels array.
+     * Normally, an audio device should only have one master channel, but this method allows for multiple master channels to be created and used if needed.
+     * @returns 
+     */
+    public createMasterChannel(): Master {
 
         const master = new Master(this.context);
 
@@ -40,11 +64,30 @@ export class AudioDevice {
         return master;
     }
 
-    public GetContext(): AudioContext {
+    /**
+     * Returns the audio context associated with this audio device.
+     * This method is provided for ease of use, and is a wrapper for the context property.
+     * 
+     * The audio context can vary between audio devices, and is used to create channels and master channels that are associated with this audio device.
+     */
+    public getContext(): AudioContext {
         return this.context;
     }
 
-    public CreateChannel(label?: string): Channel {
+    /**
+     * Creates a new channel based on the this audio device's audio context.
+     * This method is a wrapper for the Channel constructor, and is provided for ease of use.
+     * In case you want to create a channel with a different audio context, you can use the Channel constructor directly.
+     * 
+     * @example 
+     * ```
+     * const myChannel: Channel = audioDevice.createChannel("My Channel");
+     * ```
+     * 
+     * @param label 
+     * @returns 
+     */
+    public createChannel(label?: string): Channel {
         return new Channel(this.context, label);
     }
 }