@vnejs/plugins.audio 0.1.1

package/const/const.js

@@ -0,0 +1,4 @@
+export const ACTIONS = { PLAY: "play", STOP: "stop", PAUSE: "pause", RESUME: "resume", VOLUME: "volume" };
+
+export const LINE_EXEC_REG = /^((?<action>play|stop|pause|resume|volume) )?({(?<name>.+?)} )?(?<durations>[0-9:]+)?$/;
+export const LINE_LOAD_REG = /{(?<name>.+?)}/;

package/const/events.js

@@ -0,0 +1,19 @@
+export const SUBSCRIBE_EVENTS = {
+  PLAY: "vne:audio:play",
+  STOP: "vne:audio:stop",
+  PAUSE: "vne:audio:pause",
+  RESUME: "vne:audio:resume",
+
+  MEDIA_LOAD: "vne:audio:media_load",
+  MEDIA_GET: "vne:audio:media_get",
+
+  VOLUME: "vne:audio:volume",
+  VOLUME_GET: "vne:audio:volume_get",
+  VOLUME_CHANGED: "vne:audio:volume_changed",
+
+  PREPARE_PLAY: "vne:audio:prepare_play",
+
+  TMP_SET: "vne:audio:tmp_set",
+  TMP_GET: "vne:audio:tmp_get",
+  TMP_RM: "vne:audio:tmp_rm",
+};

package/const/params.js

@@ -0,0 +1,3 @@
+export const DEFAULT_VOLUME = 1;
+
+export const QUALITY = "128k";

package/const/settings.js

@@ -0,0 +1,3 @@
+export const SETTINGS_KEYS = {
+  VOLUME: "vne:audio:volume",
+};

package/index.js

@@ -0,0 +1,24 @@
+import { regPlugin } from "@vnejs/shared";
+
+import * as constants from "./const/const";
+import { SUBSCRIBE_EVENTS } from "./const/events";
+import * as params from "./const/params";
+import { SETTINGS_KEYS } from "./const/settings";
+
+import { AudioTmp } from "./modules/tmp";
+import { AudioPlay } from "./modules/play";
+import { AudioStop } from "./modules/stop";
+import { AudioPause } from "./modules/pause";
+import { AudioMedia } from "./modules/media";
+import { AudioResume } from "./modules/resume";
+import { AudioVolume } from "./modules/volume";
+
+regPlugin("AUDIO", { constants, events: SUBSCRIBE_EVENTS, params, settings: SETTINGS_KEYS }, [
+  AudioTmp,
+  AudioPlay,
+  AudioStop,
+  AudioMedia,
+  AudioPause,
+  AudioVolume,
+  AudioResume,
+]);

package/modules/media.js

@@ -0,0 +1,23 @@
+import { Module } from "@vnejs/module";
+
+export class AudioMedia extends Module {
+  name = "audio.media";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.MEDIA_LOAD, this.onAudioMediaLoad);
+    this.on(this.EVENTS.AUDIO.MEDIA_GET, this.onAudioMediaGet);
+  };
+
+  init = () => {
+    this.quality = this.PARAMS.AUDIO.QUALITY;
+  };
+
+  onAudioMediaLoad = ({ name, layer: mediaType, priority = this.CONST.MEDIA.PRIORITIES.BACKGROUND } = {}) => {
+    const [type, quality] = [this.CONST.MEDIA.TYPES.AUDIO, this.quality];
+
+    return name && this.emit(this.EVENTS.MEDIA.LOAD, { type, quality, name, mediaType, priority });
+  };
+
+  onAudioMediaGet = ({ name, layer: mediaType } = {}) =>
+    this.emitOne(this.EVENTS.MEDIA.GET, { type: this.CONST.MEDIA.TYPES.AUDIO, quality: this.quality, mediaType, name });
+}

package/modules/pause.js

@@ -0,0 +1,42 @@
+import { Module } from "@vnejs/module";
+
+export class AudioPause extends Module {
+  name = "audio.pause";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.PAUSE, this.onAudioPause);
+  };
+
+  onAudioPause = async ({ layer, name, duration } = {}) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+    const audio = await this.emitOne(this.EVENTS.AUDIO.TMP_GET, { src: media.src });
+
+    if (!duration) return audio.pause();
+
+    return new Promise(async (resolve) => {
+      const initialVolume = await this.emitOne(this.EVENTS.AUDIO.VOLUME_GET, { layer, name });
+      const initialTs = new Date().getTime();
+
+      const onTick = () => {
+        const ts = new Date().getTime();
+
+        if (ts - initialTs >= duration || audio.currentTime + 0.1 >= audio.duration) {
+          audio.pause();
+
+          this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume: initialVolume });
+
+          return resolve();
+        }
+
+        const delta = (ts - initialTs) / duration;
+        const newVolume = Math.max((1 - delta) * initialVolume, 0);
+
+        this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume: newVolume });
+
+        requestAnimationFrame(onTick);
+      };
+
+      requestAnimationFrame(onTick);
+    });
+  };
+}

package/modules/play.js

@@ -0,0 +1,56 @@
+import { Module } from "@vnejs/module";
+
+export class AudioPlay extends Module {
+  name = "audio.play";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.PLAY, this.onAudioPlay);
+  };
+
+  onAudioPlay = ({ layer, name, durations: [startDuration, finishDuration], volume = 100, isLoop = true } = {}) =>
+    this.playAudio(layer, name, startDuration, finishDuration, volume, isLoop);
+
+  playAudio = async (layer, name, startDuration, finishDuration, volume, isLoop) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+
+    const { audio, track, gainNode } = this.prepareMedia(media, startDuration, finishDuration);
+
+    await this.emit(this.EVENTS.AUDIO.TMP_SET, { media: audio });
+
+    const onEnded = async () => {
+      const newVolume = await this.emitOne(this.EVENTS.AUDIO.VOLUME_GET, { layer, name });
+
+      audio.removeEventListener("ended", onEnded);
+
+      track.disconnect();
+      gainNode.disconnect();
+
+      audio.remove();
+
+      await this.emit(this.EVENTS.AUDIO.TMP_RM, { src: media.src });
+
+      if (isLoop) return this.playAudio(layer, name, startDuration, finishDuration, newVolume, isLoop);
+    };
+
+    audio.addEventListener("ended", onEnded);
+
+    await audio.play();
+
+    await this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume });
+  };
+
+  prepareMedia = (media, startDuration, finishDuration) => {
+    const [audio, ctx] = [new Audio(media.src), new AudioContext()];
+    const [track, gainNode] = [ctx.createMediaElementSource(audio), ctx.createGain()];
+
+    track.connect(gainNode);
+    gainNode.connect(ctx.destination);
+
+    gainNode.gain.setValueAtTime(0, 0);
+    gainNode.gain.linearRampToValueAtTime(1, startDuration / 1000);
+    gainNode.gain.setValueAtTime(1, media.duration - finishDuration / 1000);
+    gainNode.gain.linearRampToValueAtTime(0, media.duration);
+
+    return { audio, track, gainNode };
+  };
+}

package/modules/resume.js

@@ -0,0 +1,40 @@
+import { Module } from "@vnejs/module";
+
+export class AudioResume extends Module {
+  name = "audio.resume";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.RESUME, this.onAudioResume);
+  };
+
+  onAudioResume = async ({ layer, name, duration } = {}) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+    const audio = await this.emitOne(this.EVENTS.AUDIO.TMP_GET, { src: media.src });
+
+    if (!duration) return audio.play();
+
+    return new Promise(async (resolve) => {
+      const initialVolume = await this.emitOne(this.EVENTS.AUDIO.VOLUME_GET, { layer, name });
+      const initialTs = new Date().getTime();
+
+      await this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume: 0 });
+      await audio.play();
+
+      const onTick = () => {
+        const ts = new Date().getTime();
+
+        if (ts - initialTs >= duration || audio.currentTime + 0.1 >= audio.duration)
+          return this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume: initialVolume }).then(resolve);
+
+        const delta = (ts - initialTs) / duration;
+        const newVolume = delta * initialVolume;
+
+        this.emit(this.EVENTS.AUDIO.VOLUME, { layer, name, volume: newVolume });
+
+        requestAnimationFrame(onTick);
+      };
+
+      requestAnimationFrame(onTick);
+    });
+  };
+}

package/modules/stop.js

@@ -0,0 +1,23 @@
+import { Module } from "@vnejs/module";
+
+export class AudioStop extends Module {
+  name = "audio.stop";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.STOP, this.onAudioStop);
+  };
+
+  onAudioStop = async ({ layer, name, duration = 0 } = {}) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+    const oldAudio = await this.emitOne(this.EVENTS.AUDIO.TMP_GET, { src: media.src });
+
+    if (!oldAudio) return;
+
+    if (duration) await this.emit(this.EVENTS.AUDIO.PAUSE, { layer, name, duration });
+    else oldAudio.pause();
+
+    oldAudio.remove();
+
+    return this.emit(this.EVENTS.AUDIO.TMP_RM, { src: media.src });
+  };
+}

package/modules/tmp.js

@@ -0,0 +1,24 @@
+import { Module } from "@vnejs/module";
+
+export class AudioTmp extends Module {
+  name = "audio.tmp";
+
+  medias = {};
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.TMP_SET, this.onAudioTmpSet);
+    this.on(this.EVENTS.AUDIO.TMP_GET, this.onAudioTmpGet);
+    this.on(this.EVENTS.AUDIO.TMP_RM, this.onAudioTmpRm);
+  };
+
+  onAudioTmpSet = ({ media } = {}) => {
+    this.medias[media.src] = media;
+  };
+  onAudioTmpGet = ({ src } = {}) => this.medias[src];
+  onAudioTmpRm = ({ src } = {}) => {
+    if (!this.medias[src]) return;
+
+    this.medias[src].remove();
+    delete this.medias[src];
+  };
+}

package/modules/volume.js

@@ -0,0 +1,34 @@
+import { Module } from "@vnejs/module";
+
+export class AudioVolume extends Module {
+  name = "audio.volume";
+
+  subscribe = () => {
+    this.on(this.EVENTS.AUDIO.VOLUME, this.onAudioVolume);
+    this.on(this.EVENTS.AUDIO.VOLUME_GET, this.onAudioVolumeGet);
+
+    this.on(this.EVENTS.SETTINGS.CHANGED, this.onSettingsChanged);
+  };
+
+  init = () => this.emit(this.EVENTS.SETTINGS.INIT, { name: this.SETTINGS.AUDIO.VOLUME, value: 100 });
+
+  onSettingsChanged = ({ name }) => name === this.SETTINGS.AUDIO.VOLUME && this.emit(this.EVENTS.AUDIO.VOLUME_CHANGED);
+
+  onAudioVolume = async ({ layer, name, volume = 100 } = {}) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+    const audio = await this.emitOne(this.EVENTS.AUDIO.TMP_GET, { src: media.src });
+
+    const commonVolume = this.shared.settings[this.SETTINGS.AUDIO.VOLUME] / 100;
+
+    if (audio) audio.volume = (commonVolume * volume) / 100;
+  };
+
+  onAudioVolumeGet = async ({ layer, name } = {}) => {
+    const media = await this.emitOne(this.EVENTS.AUDIO.MEDIA_GET, { layer, name });
+    const audio = await this.emitOne(this.EVENTS.AUDIO.TMP_GET, { src: media.src });
+
+    const commonVolume = this.shared.settings[this.SETTINGS.AUDIO.VOLUME] / 100;
+
+    if (audio) return (100 * audio.volume) / commonVolume;
+  };
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@vnejs/plugins.audio",
+  "version": "0.1.1",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "publish:major:plugin": "npm run publish:major",
+    "publish:minor:plugin": "npm run publish:minor",
+    "publish:patch:plugin": "npm run publish:patch",
+    "publish:major": "npm version major && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:patch": "npm version patch && npm publish --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}