one/dist/cjs/platform/audio/player.cjs

One is a React framework for web, iOS, and Android apps.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var player_exports = {};
__export(player_exports, {
	AudioPlayer: () => AudioPlayer,
	createPlayer: () => createPlayer
});
module.exports = __toCommonJS(player_exports);
var import_events = require("./events.cjs");
var import_validate = require("./validate.cjs");
var AudioPlayer = class {
	element;
	playerId;
	removed = false;
	events;
	buffering = false;
	finished = false;
	failure = null;
	constructor(element, id, updateIntervalMs) {
		this.element = element;
		this.playerId = id;
		this.events = (0, import_events.createPlayerEvents)(() => this.getStatus(), updateIntervalMs);
		element.addEventListener("waiting", () => {
			this.buffering = true;
		});
		element.addEventListener("playing", () => {
			this.buffering = false;
			this.failure = null;
		});
		element.addEventListener("canplay", () => {
			this.buffering = false;
		});
		element.addEventListener("ended", () => {
			this.finished = true;
		});
		element.addEventListener("error", () => {
			this.failure = element.error?.message || "audio playback failed";
		});
	}
	get id() {
		return this.playerId;
	}
	get currentTime() {
		this.assertUsable("currentTime");
		return this.element.currentTime;
	}
	get duration() {
		this.assertUsable("duration");
		const duration = this.element.duration;
		return Number.isFinite(duration) ? duration : 0;
	}
	get playing() {
		this.assertUsable("playing");
		return !this.element.paused && !this.element.ended;
	}
	get paused() {
		this.assertUsable("paused");
		return this.isLoaded && !this.playing;
	}
	get isLoaded() {
		this.assertUsable("isLoaded");
		return this.element.readyState >= 2;
	}
	get isBuffering() {
		this.assertUsable("isBuffering");
		return this.buffering;
	}
	get isAudioSamplingSupported() {
		return false;
	}
	get loop() {
		this.assertUsable("loop");
		return this.element.loop;
	}
	set loop(value) {
		this.assertUsable("loop");
		(0, import_validate.assertFlag)(value, "AudioPlayer.loop");
		this.element.loop = value;
	}
	get muted() {
		this.assertUsable("muted");
		return this.element.muted;
	}
	set muted(value) {
		this.assertUsable("muted");
		(0, import_validate.assertFlag)(value, "AudioPlayer.muted");
		this.element.muted = value;
	}
	get volume() {
		this.assertUsable("volume");
		return this.element.volume;
	}
	set volume(value) {
		this.assertUsable("volume");
		(0, import_validate.assertVolume)(value, "AudioPlayer.volume");
		this.element.volume = value;
	}
	get playbackRate() {
		this.assertUsable("playbackRate");
		return this.element.playbackRate;
	}
	get shouldCorrectPitch() {
		this.assertUsable("shouldCorrectPitch");
		return this.element.preservesPitch;
	}
	set shouldCorrectPitch(value) {
		this.assertUsable("shouldCorrectPitch");
		(0, import_validate.assertFlag)(value, "AudioPlayer.shouldCorrectPitch");
		this.element.preservesPitch = value;
	}
	play() {
		this.assertUsable("play");
		this.finished = false;
		const started = this.element.play();
		if (started && typeof started.catch === "function") {
			started.catch((error) => {
				this.failure = error instanceof Error ? error.message : "audio playback failed";
			});
		}
	}
	pause() {
		this.assertUsable("pause");
		this.element.pause();
	}
	seekTo(seconds, toleranceMillisBefore, toleranceMillisAfter) {
		this.assertUsable("seekTo");
		(0, import_validate.assertSeconds)(seconds, "AudioPlayer.seekTo");
		if (toleranceMillisBefore !== void 0) {
			(0, import_validate.assertTolerance)(toleranceMillisBefore, "AudioPlayer.seekTo");
		}
		if (toleranceMillisAfter !== void 0) {
			(0, import_validate.assertTolerance)(toleranceMillisAfter, "AudioPlayer.seekTo");
		}
		this.finished = false;
		this.element.currentTime = seconds;
		if (!this.element.seeking) return Promise.resolve();
		return new Promise((resolve) => {
			this.element.addEventListener("seeked", () => resolve(), { once: true });
		});
	}
	replace(source) {
		this.assertUsable("replace");
		const normalized = (0, import_validate.normalizeSource)(source, "AudioPlayer.replace");
		this.finished = false;
		this.failure = null;
		if (normalized.uri === void 0) {
			this.element.removeAttribute("src");
		} else {
			this.element.src = normalized.uri;
		}
		this.element.load();
	}
	remove() {
		if (this.removed) return;
		this.removed = true;
		this.events.removeAll();
		this.element.pause();
		this.element.removeAttribute("src");
		this.element.load();
	}
	getStatus() {
		this.assertUsable("getStatus");
		return {
			currentTime: this.currentTime,
			didJustFinish: this.finished,
			duration: this.duration,
			error: this.failure,
			id: this.playerId,
			isBuffering: this.isBuffering,
			isLoaded: this.isLoaded,
			loop: this.loop,
			mute: this.muted,
			playbackRate: this.playbackRate,
			playing: this.playing,
			shouldCorrectPitch: this.shouldCorrectPitch
		};
	}
	setPlaybackRate(rate, pitchCorrectionQuality) {
		this.assertUsable("setPlaybackRate");
		(0, import_validate.assertRate)(rate, "AudioPlayer.setPlaybackRate");
		if (pitchCorrectionQuality !== void 0) {
			(0, import_validate.assertPitchQuality)(pitchCorrectionQuality, "AudioPlayer.setPlaybackRate");
		}
		if (rate < 0 || rate > 2) throw (0, import_validate.rateError)("AudioPlayer.setPlaybackRate");
		this.element.playbackRate = rate;
	}
	addListener(event, listener) {
		this.assertUsable("addListener");
		return this.events.add(event, listener);
	}
	removeAllListeners() {
		this.events.removeAll();
	}
	assertUsable(verb) {
		if (this.removed) throw new Error(`AudioPlayer.${verb}: the player was removed`);
	}
};
function createPlayer(source = null, options = {}) {
	const normalized = (0, import_validate.normalizeSource)(source, "Audio.createPlayer");
	const updateIntervalMs = (0, import_validate.resolveUpdateInterval)(options, "Audio.createPlayer");
	(0, import_validate.assertCrossOrigin)(options.crossOrigin, "Audio.createPlayer");
	const element = new Audio();
	element.preload = "auto";
	if (options.crossOrigin !== void 0) element.crossOrigin = options.crossOrigin;
	if (normalized.uri !== void 0) element.src = normalized.uri;
	const id = `player-${AudioPlayerId.next++}`;
	return new AudioPlayer(element, id, updateIntervalMs);
}
const AudioPlayerId = { next: 1 };