one/dist/esm/platform/audio/validate.native.js

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

var 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`);
	var { 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`);
		}
		var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
		try {
			for (var _iterator = Object.values(headers)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
				var value = _step.value;
				if (typeof value !== "string") {
					throw new Error(`${owner}: expected source header values to be strings`);
				}
			}
		} catch (err) {
			_didIteratorError = true;
			_iteratorError = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion && _iterator.return != null) {
					_iterator.return();
				}
			} finally {
				if (_didIteratorError) {
					throw _iteratorError;
				}
			}
		}
	}
	return {
		...uri !== void 0 && { uri },
		...headers !== void 0 && { headers }
	};
}
function resolveUpdateInterval(options, owner) {
	var _ref;
	var interval = (_ref = options === null || options === void 0 ? void 0 : options.updateInterval) !== null && _ref !== void 0 ? _ref : 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" });
}

export { assertCrossOrigin, assertFlag, assertPitchQuality, assertRate, assertSeconds, assertTolerance, assertVolume, normalizeSource, rateError, resolveUpdateInterval };
//# sourceMappingURL=validate.native.js.map