one/dist/cjs/platform/audio/validate.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 validate_exports = {};
__export(validate_exports, {
	assertCrossOrigin: () => assertCrossOrigin,
	assertFlag: () => assertFlag,
	assertPitchQuality: () => assertPitchQuality,
	assertRate: () => assertRate,
	assertSeconds: () => assertSeconds,
	assertTolerance: () => assertTolerance,
	assertVolume: () => assertVolume,
	normalizeSource: () => normalizeSource,
	rateError: () => rateError,
	resolveUpdateInterval: () => resolveUpdateInterval
});
module.exports = __toCommonJS(validate_exports);
const qualities = /* @__PURE__ */ new Set([
	"low",
	"medium",
	"high"
]);
function normalizeSource(source, owner) {
	if (source === null || source === void 0) return {};
	if (typeof source === "number") {
		throw new Error(`${owner}: assetId sources are not supported`);
	}
	if (typeof source === "string") {
		if (source.trim() === "") throw new Error(`${owner}: expected a non-empty audio uri`);
		return { uri: source };
	}
	if (typeof source !== "object") throw new Error(`${owner}: expected an audio source`);
	const { uri, headers, name } = source;
	if (uri !== void 0 && (typeof uri !== "string" || uri.trim() === "")) {
		throw new Error(`${owner}: expected a non-empty audio uri`);
	}
	if (name !== void 0 && typeof name !== "string") {
		throw new Error(`${owner}: expected a string source name`);
	}
	if (headers !== void 0) {
		if (typeof headers !== "object" || headers === null || Array.isArray(headers)) {
			throw new Error(`${owner}: expected source headers to be an object`);
		}
		for (const value of Object.values(headers)) {
			if (typeof value !== "string") {
				throw new Error(`${owner}: expected source header values to be strings`);
			}
		}
	}
	return {
		...uri !== void 0 && { uri },
		...headers !== void 0 && { headers }
	};
}
function resolveUpdateInterval(options, owner) {
	const interval = options?.updateInterval ?? 500;
	if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0) {
		throw new Error(`${owner}: expected updateInterval to be a positive number of milliseconds`);
	}
	return interval;
}
function assertCrossOrigin(crossOrigin, owner) {
	if (crossOrigin !== void 0 && crossOrigin !== "anonymous" && crossOrigin !== "use-credentials") {
		throw new Error(`${owner}: expected crossOrigin 'anonymous' or 'use-credentials'`);
	}
}
function assertRate(rate, owner) {
	if (typeof rate !== "number" || !Number.isFinite(rate)) {
		throw new Error(`${owner}: expected a finite playback rate`);
	}
}
function assertPitchQuality(quality, owner) {
	if (typeof quality !== "string" || !qualities.has(quality)) {
		throw new Error(`${owner}: expected pitch quality 'low', 'medium' or 'high'`);
	}
}
function assertVolume(volume, owner) {
	if (typeof volume !== "number" || !Number.isFinite(volume) || volume < 0 || volume > 1) {
		throw new Error(`${owner}: expected volume between 0 and 1`);
	}
}
function assertSeconds(seconds, owner) {
	if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds < 0) {
		throw new Error(`${owner}: expected a finite nonnegative seek position in seconds`);
	}
}
function assertTolerance(tolerance, owner) {
	if (typeof tolerance !== "number" || !Number.isFinite(tolerance) || tolerance < 0) {
		throw new Error(`${owner}: expected a finite nonnegative tolerance in milliseconds`);
	}
}
function assertFlag(value, owner) {
	if (typeof value !== "boolean") throw new Error(`${owner}: expected a boolean`);
}
function rateError(owner) {
	return Object.assign(new Error(`${owner}: playback rate is outside the platform range`), { code: "E_AUDIO_RATE" });
}