@bvdmitri/gyroview 0.0.0-stage → 0.9.0-cutaway.2

package/dist/packages/player/src/player/SessionRelay.js

@@ -0,0 +1,74 @@
+import { transportEventsFor } from "./transportEvents.js";
+//#region ../../packages/player/src/player/SessionRelay.ts
+/**
+* Relays the loaded session's events in media-element terms: transport events for its state
+* changes, time updates, drawn frames, finished seeks, errors and the end. Listens to one session at a time and
+* stops before that session is disposed, so its disposal is never announced. A change is relayed
+* whole, as a media element fires the events it queued before a listener's `pause()`; the
+* session announces a listener's newer change after it (ADR 0021).
+*/
+var SessionRelay = class {
+	targets;
+	stopListening = [];
+	lastState;
+	/**
+	* Counts detachments, so a change whose listener let the session go stops relaying.
+	*/
+	detachments = 0;
+	constructor(targets) {
+		this.targets = targets;
+	}
+	attach(session) {
+		this.detach();
+		this.lastState = session.state;
+		const { events } = this.targets;
+		this.stopListening = [
+			session.events.on("statechange", (state) => {
+				this.onStateChange(state, session);
+			}),
+			session.events.on("timeupdate", (time) => {
+				events.emit("timeupdate", time);
+			}),
+			session.events.on("present", (time) => {
+				events.emit("frame", time);
+			}),
+			session.events.on("seeked", (time) => {
+				this.onSeeked(time, session);
+			}),
+			session.events.on("ended", () => {
+				events.emit("ended", void 0);
+			}),
+			session.events.on("error", (error) => {
+				events.emit("error", error);
+			})
+		];
+	}
+	detach() {
+		for (const stop of this.stopListening) stop();
+		this.stopListening = [];
+		this.lastState = void 0;
+		this.detachments += 1;
+	}
+	onStateChange(state, session) {
+		const previous = this.lastState;
+		this.lastState = state;
+		const detachments = this.detachments;
+		for (const name of transportEventsFor(previous, state)) {
+			this.emitTransport(name, session);
+			if (this.detachments !== detachments) return;
+		}
+		this.targets.onState(state);
+	}
+	onSeeked(time, session) {
+		const detachments = this.detachments;
+		this.targets.events.emit("seeked", time);
+		if (this.detachments === detachments) this.targets.onState(session.state);
+	}
+	emitTransport(name, session) {
+		const { events } = this.targets;
+		if (name === "seeking") events.emit(name, session.currentTime);
+		else events.emit(name, void 0);
+	}
+};
+//#endregion
+export { SessionRelay };

package/dist/packages/player/src/player/StatusAnnouncer.js

@@ -0,0 +1,29 @@
+//#region ../../packages/player/src/player/StatusAnnouncer.ts
+/**
+* Announces the player's status once for each change: a status announced again before listeners
+* heard the other one in between is heard once.
+*/
+var StatusAnnouncer = class {
+	outbox;
+	emitter;
+	/**
+	* The status listeners heard last.
+	*/
+	lastStatus = "idle";
+	constructor(outbox, emitter) {
+		this.outbox = outbox;
+		this.emitter = emitter;
+	}
+	/**
+	* Whether listeners hear it is decided once the change is whole, against what they heard last.
+	*/
+	announce(status) {
+		this.outbox.post(() => {
+			if (status === this.lastStatus) return;
+			this.lastStatus = status;
+			this.emitter.emit("statuschange", status);
+		});
+	}
+};
+//#endregion
+export { StatusAnnouncer };

package/dist/packages/player/src/player/ensureFinite.js

@@ -0,0 +1,26 @@
+import { degrees } from "../../../core/src/shared/units/angle.js";
+import { GyroViewError } from "../../../core/src/shared/errors/GyroViewError.js";
+//#region ../../packages/player/src/player/ensureFinite.ts
+/**
+* A number from the page, or from another origin through the embed: NaN from an empty field, an
+* undefined value or text would reach the clock and the view, which cannot take it.
+*/
+function ensureFinite(value, name) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new GyroViewError("invalid-argument", `${name} must be a finite number`);
+}
+/**
+* A view from the page, each angle checked and read as degrees, level.
+*/
+function viewStateOf(view) {
+	ensureFinite(view.yaw, "yaw");
+	ensureFinite(view.pitch, "pitch");
+	ensureFinite(view.fieldOfView, "fieldOfView");
+	return {
+		yaw: degrees(view.yaw),
+		pitch: degrees(view.pitch),
+		roll: degrees(0),
+		fieldOfView: degrees(view.fieldOfView)
+	};
+}
+//#endregion
+export { ensureFinite, viewStateOf };

package/dist/packages/player/src/player/loadRecording.js

@@ -0,0 +1,47 @@
+import { Disposables } from "../composition/Disposables.js";
+import { openRecording } from "../composition/openRecording.js";
+//#region ../../packages/player/src/player/loadRecording.ts
+/**
+* Opens the recording and builds everything that plays it on the host's canvas. Whatever was
+* built is disposed again when a step fails or the load is aborted.
+*/
+async function loadRecording(request) {
+	const { parts, signal } = request;
+	const opened = await openRecording(request.source, parts.ports, signal);
+	const disposables = new Disposables();
+	disposables.add(() => {
+		opened.dispose();
+	});
+	try {
+		const built = await parts.pipelines({
+			opened,
+			host: parts.host,
+			decoderPort: parts.ports.decoderPort,
+			signal
+		});
+		disposables.add(() => {
+			built.dispose();
+		});
+		signal.throwIfAborted();
+		return {
+			opened,
+			pipeline: built,
+			warnings: warningsOf(opened, built),
+			dispose: disposables.toDisposer()
+		};
+	} catch (error) {
+		disposables.disposeAll();
+		throw error;
+	}
+}
+function warningsOf(opened, pipeline) {
+	return [...opened.warnings.map((message) => ({
+		code: "recording-degraded",
+		message
+	})), ...pipeline.soundWarnings.map((message) => ({
+		code: "no-sound",
+		message
+	}))];
+}
+//#endregion
+export { loadRecording };

package/dist/packages/player/src/player/transportEvents.js

@@ -0,0 +1,30 @@
+//#region ../../packages/player/src/player/transportEvents.ts
+var STOPPED_STATES = /* @__PURE__ */ new Set([
+	"ready",
+	"paused",
+	"ended"
+]);
+/**
+* What flowing states announce: frames flow, or playback holds for them.
+*/
+var FLOW_EVENTS = /* @__PURE__ */ new Map([["playing", "playing"], ["buffering", "waiting"]]);
+/**
+* The transport events a session state change means to a listener who thinks in media-element
+* terms: `play` when playback is asked for, `waiting` while it holds for frames, `playing` when
+* frames flow, `pause` when it stops, at the end too, and `seeking` when a seek begins, without
+* repeating `play` or `pause`. `seeked` is the session's own: a seek is done once its first
+* picture is drawn (ADR 0042).
+*/
+function transportEventsFor(previous, next) {
+	if (next === "seeking") return ["seeking"];
+	if (previous === "seeking") return next === "buffering" ? ["waiting"] : [];
+	if (next === "paused") return previous === "ready" ? [] : ["pause"];
+	return next === "ended" ? ["pause"] : flowEventsFor(previous, next);
+}
+function flowEventsFor(previous, next) {
+	const flow = FLOW_EVENTS.get(next);
+	if (flow === void 0) return [];
+	return previous === void 0 || STOPPED_STATES.has(previous) ? ["play", flow] : [flow];
+}
+//#endregion
+export { transportEventsFor };

package/dist/packages/player/src/player/viewAngles.js

@@ -0,0 +1,17 @@
+//#region ../../packages/player/src/player/viewAngles.ts
+/**
+* The view as a page sees it: a fresh object of the three angles, the roll the device gives the
+* held view kept inside the player (ADR 0040).
+*/
+function anglesOf(view) {
+	return {
+		yaw: view.yaw,
+		pitch: view.pitch,
+		fieldOfView: view.fieldOfView
+	};
+}
+function isSameAngles(a, b) {
+	return a.yaw === b.yaw && a.pitch === b.pitch && a.fieldOfView === b.fieldOfView;
+}
+//#endregion
+export { anglesOf, isSameAngles };

package/dist/packages/player/src/rendition.js

@@ -0,0 +1,52 @@
+import { seconds } from "../../core/src/shared/units/time.js";
+import { browserPorts } from "./composition/browserPorts.js";
+import { openRecording } from "./composition/openRecording.js";
+import { renditionOf } from "./composition/renditionFrames.js";
+//#region ../../packages/player/src/rendition.ts
+/**
+* Opens a recording, as the player would, to render it frame by frame (see {@link Rendition}).
+* Rejects with the `GyroViewError` a load would meet, and with `invalid-argument` for a width or
+* span that holds no picture.
+*/
+async function openRendition(source, options) {
+	const signal = options.signal ?? new AbortController().signal;
+	const ports = browserPorts({ ...options.http && { http: options.http } });
+	const opened = await openRecording(source, ports, signal);
+	try {
+		return renditionOver(opened, renditionOf({
+			opened,
+			decoderPort: ports.decoderPort,
+			...options.canvas && { canvas: options.canvas }
+		}, requestOf(options)), signal);
+	} catch (error) {
+		opened.dispose();
+		throw error;
+	}
+}
+function requestOf(options) {
+	const { width, from, to, stabilization, gainMatching, quality } = options;
+	return {
+		width,
+		...from !== void 0 && { from: seconds(from) },
+		...to !== void 0 && { to: seconds(to) },
+		...stabilization && { stabilization },
+		...gainMatching !== void 0 && { gainMatching },
+		...quality && { quality }
+	};
+}
+function renditionOver(opened, frames, signal) {
+	const dispose = () => {
+		frames.dispose();
+		opened.dispose();
+	};
+	signal.addEventListener("abort", dispose, { once: true });
+	return {
+		metadata: opened.metadata,
+		...frames.size,
+		duration: frames.span.duration,
+		frames: () => frames.frames(),
+		dispose
+	};
+}
+//#endregion
+export { openRendition };