misairu 4.1.0 → 5.0.1

package/src/types.ts

@@ -0,0 +1,58 @@
+import { Misairu } from './misairu'
+
+/**
+ * Type describing the structure of the event cache
+ */
+export type EventCache = {
+  [trackName: string]: string
+}
+
+/**
+ * Type describing the available arguments of event functions
+ */
+export type EventFunction = (
+  instance: Misairu,
+  timingKey: string,
+  track: string,
+  time: number
+) => void
+
+/**
+ * Type describing the structure of an event track
+ */
+export type EventTrack = {
+  [timingKey: string]: EventFunction
+}
+
+/**
+ * Type describing the structure of the timing object
+ */
+export type TimingObject = {
+  [trackName: string]: EventTrack
+}
+
+/**
+ * Interface describing required methods/members for track processors
+ */
+export interface ITrackProcessor {
+  /**
+   * Member describing if the processed track should be deleted
+   */
+  deleteOriginTrack: boolean
+
+  /**
+   * Method to check if the track name matches to determine if the processor
+   * should process it
+   * 
+   * @param name name oƒ a track
+   */
+  matches(name: string): boolean
+
+  /**
+   * Main processing method
+   * 
+   * @param name name of the track to be processed
+   * @param track content of the track to be processed
+   */
+  process(name: string, track: EventTrack | EventFunction): [string, EventTrack]
+}

package/src/utilities/audio.ts

@@ -0,0 +1,22 @@
+/**
+ * Method to turn the passed decibel values into volume values for the audio playback
+ *
+ * @param db decibel value
+ * @returns volume value
+ */
+export function dbToVolume(db: number): number {
+  return Math.pow(10, db / 20)
+}
+
+/**
+ * Clamps the volume to a min/max value to prevent accidental oversetting to way too loud measures
+ */
+export function clampGain(volume: number): number {
+  if (volume < -80) {
+    return -80
+  } else if (volume > 5) {
+    return 5
+  }
+
+  return volume
+}

package/src/utilities/source.ts

@@ -0,0 +1,28 @@
+/**
+ * Method to fetch the external audio file (if the audio source parameter was a string)
+ * and turning it into a `AudioBufferSourceNode`
+ *
+ * @param audioSource the audio source `Misairu` has been constructed with
+ * @internal
+ */
+export async function fetchAudioSource(audioSource: string, audioContext: AudioContext): Promise<AudioBufferSourceNode> {
+  const source = audioContext.createBufferSource()
+
+  const response = await fetch(audioSource)
+  const arrayBuffer = await response.arrayBuffer()
+  const buffer = await audioContext.decodeAudioData(arrayBuffer)
+
+  source.buffer = buffer
+
+  return source
+}
+
+/**
+ * Method to get an `MediaElementAudioSourceNode` from the passed audio source
+ *
+ * @param audioSource the audio source `Misairu` has been constructed with
+ * @internal
+ */
+export function attachAudioElementSource(audioSource: HTMLMediaElement, audioContext: AudioContext): MediaElementAudioSourceNode {
+  return audioContext.createMediaElementSource(audioSource)
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "suppressImplicitAnyIndexErrors": true
+  }
+}

package/misairu.js

@@ -1,255 +0,0 @@
-/* misairu
- * https://github.com/pixeldesu/misairu
- * 
- * 
- * Copyright pixeldesu and other contributors
- * Licensed under the MIT License
- * https://github.com/pixeldesu/misairu/blob/master/LICENSE
- */
-
-class misairu {
-  constructor (audioSource, timings) {
-    if (timings === null) console.error('You need to specify a timings object');
-    this.timings = timings;
-
-    this.audioContext = new AudioContext();
-    this.audioElement = null;
-
-    this.gainNode = this.audioContext.createGain();
-    this.gainNode.connect(this.audioContext.destination);
-
-    this.audioSource = audioSource;
-
-    this.eventHandler = null;
-
-    this.cache = {};
-  }
-
-  set audioContext (audioContext) {
-    this._audioContext = audioContext;
-  }
-
-  get audioContext () {
-    return this._audioContext;
-  }
-
-  set audioSource (audioSource) {
-    if (typeof audioSource == "string") {
-      this.fetchAudioSource(audioSource);
-    } else if (typeof audioSource == "object" && (audioSource.tagName == "AUDIO" || audioSource.tagName == "VIDEO")) {
-      this.attachAudioElementSource(audioSource);
-    }
-  }
-
-  get audioSource () {
-    return this._audioSource;
-  }
-
-  set gainNode (gainNode) {
-    this._gainNode = gainNode;
-  }
-
-  get gainNode () {
-    return this._gainNode;
-  }
-
-  set audioElement (audioElement) {
-    this._audioElement = audioElement;
-  }
-
-  get audioElement () {
-    return this._audioElement;
-  } 
-
-  set startTime (startTime) {
-    this._startTime = startTime;
-  }
-
-  get startTime () {
-    return this._startTime;
-  }
-
-  set timings (timings) {
-    this._timings = timings;
-  }
-
-  get timings () {
-    return this._timings;
-  }
-
-  set cache (cache) {
-    this._cache = cache;
-  }
-
-  get cache () {
-    return this._cache;
-  }
-
-  set eventHandler (eventHandler) {
-    this._eventHandler = eventHandler; 
-  }
-
-  get eventHandler () {
-    return this._eventHandler;
-  }
-
-  set muted (muted) {
-    this._muted = muted;
-  }
-
-  get muted () {
-    return this._muted;
-  }
-
-  set volume (db) {
-    this._volume = db;
-    this.clampGain();
-
-    if (!this.muted) {
-      this.gainNode.gain.value = this.dbToVolume(this._volume);
-    }
-  }
-
-  get volume () {
-    return this._volume;
-  }
-
-  set paused (paused) {
-    this._paused = paused;
-  }
-
-  get paused () {
-    return this._paused;
-  }
-
-  clampGain () {
-    if (this._volume < -80) {
-      this._volume = -80;
-    } else if (this._volume > 5) {
-      this._volume = 5;
-    }
-  }
-
-  dbToVolume (db) {
-    return Math.pow(10, db / 20);
-  }
-
-  mute() {
-    if (!this.muted) {
-      this.muted = true;
-      this.gainNode.gain.value = 0;
-    }
-  }
-
-  unmute() {
-    if (this.muted) {
-      this.muted = false;
-      this.gainNode.gain.value = this.dbToVolume(this._volume);
-    }
-  }
-
-  pause () {
-    if (!this.paused) {
-      this.audioContext.suspend();
-      this.paused = true;
-    }
-  }
-
-  unpause () {
-    if (this.paused) {
-      this.audioContext.resume();
-      this.paused = false;
-    }
-  }
-
-  setCacheEntry (track, entry) {
-    this.cache[track] = entry;
-  }
-
-  getTrackCache (track) {
-    return this.cache[track];
-  }
-
-  getAllTracks () {
-    return Object.keys(this.timings);
-  }
-
-  getActiveTimingKey (track, currentTime) {
-    const timingKeys = Object.keys(this.timings[track]);
-
-    var activeTimings = timingKeys.filter(function (timing) {
-      if (currentTime >= parseFloat(timing)) {
-        return true;
-      }
-    })
-  
-    return activeTimings[activeTimings.length - 1];
-  }
-
-  fetchAudioSource (audioSource) {
-    let that = this;
-    let source = this.audioContext.createBufferSource();
-
-    fetch(audioSource).then((response) => {
-      return response.arrayBuffer()
-    }).then((arrayBuffer) => {
-      that.audioContext.decodeAudioData(arrayBuffer)
-        .then((buffer) => {
-          source.buffer = buffer;
-          source.connect(this.gainNode);
-
-          document.dispatchEvent(new Event('misairu.ready'));
-          this._audioSource = source;
-        })
-    })
-  }
-
-  attachAudioElementSource (audioSource) {
-    let source = this.audioContext.createMediaElementSource(audioSource);
-    this.audioElement = audioSource;
-    
-    source.connect(this.gainNode);
-    this._audioSource = source;
-  }
-
-  start () {
-    this.startTime = this.audioContext.currentTime;
-
-    if (this.audioElement !== null) {
-      this.audioElement.play();
-    } else {
-      this.audioSource.start();
-    }
-
-    this.startEventHandling();
-  }
-
-  startEventHandling () {
-    if (this.eventHandler == null) {
-      this.eventHandler = window.requestAnimationFrame(this.handleEvents.bind(this));
-    }
-  }
-
-  handleEvents () {
-    let time = this.audioContext.currentTime - this.startTime;
-
-    this.getAllTracks().forEach(function (track) {
-      let timingKey = this.getActiveTimingKey(track, time);
-
-      if (timingKey !== null && !(this.getTrackCache(track) == timingKey)) {
-        this.executeEvent(track, timingKey, time);
-        this.setCacheEntry(track, timingKey);
-      }
-    }.bind(this))
-
-    this.eventHandler = window.requestAnimationFrame(this.handleEvents.bind(this));
-  }
-
-  executeEvent (track, timingKey, time) {
-    this.timings[track][timingKey](this, timingKey, track, time);
-  }
-}
-
-if (typeof module === 'object' && module.exports) {
-  module.exports = misairu;
-}