mattebox 0.1.0

package/dist/es2015/kernel/append-queue.js

@@ -0,0 +1,148 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/objectSpread2.js";
+//#region src/kernel/append-queue.ts
+function isQuotaError(err) {
+	return err instanceof DOMException && err.name === "QuotaExceededError";
+}
+function isInvalidState(err) {
+	return err instanceof DOMException && err.name === "InvalidStateError";
+}
+function createAppendQueue(sbId, sb, cb) {
+	const ops = [];
+	let quotaAttempts = 0;
+	let destroyed = false;
+	let pumping = false;
+	function execute(op) {
+		try {
+			switch (op.op) {
+				case "append":
+					sb.appendBuffer(op.data);
+					quotaAttempts = 0;
+					return true;
+				case "remove": {
+					const { buffered } = sb;
+					if (buffered.length === 0 || op.start >= buffered.end(buffered.length - 1)) return false;
+					sb.remove(op.start, op.end);
+					return true;
+				}
+				case "changeType":
+					sb.changeType(op.type);
+					return false;
+				case "setTimestampOffset":
+					sb.timestampOffset = op.offset;
+					return false;
+			}
+		} catch (err) {
+			if (op.op === "append" && isQuotaError(err)) {
+				ops.unshift(op);
+				quotaAttempts += 1;
+				cb.onQuota(sbId, quotaAttempts);
+				return false;
+			}
+			if (isInvalidState(err)) {
+				destroy();
+				return false;
+			}
+			cb.absorb({
+				type: "SOURCEBUFFER_ERROR",
+				sbId,
+				error: {
+					category: "media",
+					code: "MEDIA_APPEND_FAILED",
+					fatal: true,
+					recoverable: false,
+					context: {
+						operation: op.op,
+						message: String(err)
+					}
+				}
+			});
+			return false;
+		}
+		return false;
+	}
+	function pump() {
+		if (destroyed || pumping) return;
+		pumping = true;
+		try {
+			while (!sb.updating && !destroyed) {
+				const op = ops.shift();
+				if (op === void 0) {
+					cb.onIdle(sbId);
+					return;
+				}
+				if (execute(op)) return;
+				if (op.op === "append" && ops[0] === op) return;
+			}
+		} finally {
+			pumping = false;
+		}
+	}
+	function snapshotRanges() {
+		try {
+			const out = [];
+			const { buffered } = sb;
+			for (let i = 0; i < buffered.length; i += 1) out.push({
+				start: buffered.start(i),
+				end: buffered.end(i)
+			});
+			return out;
+		} catch (_unused) {
+			return;
+		}
+	}
+	function onUpdateEnd() {
+		if (destroyed) return;
+		const ranges = snapshotRanges();
+		cb.absorb(_objectSpread2({
+			type: "SOURCEBUFFER_UPDATEEND",
+			sbId
+		}, ranges !== void 0 ? { ranges } : {}));
+		pump();
+	}
+	function onError() {
+		if (destroyed) return;
+		cb.absorb({
+			type: "SOURCEBUFFER_ERROR",
+			sbId,
+			error: {
+				category: "media",
+				code: "MEDIA_APPEND_FAILED",
+				fatal: false,
+				recoverable: true
+			}
+		});
+	}
+	function destroy() {
+		if (destroyed) return;
+		destroyed = true;
+		ops.length = 0;
+		sb.removeEventListener("updateend", onUpdateEnd);
+		sb.removeEventListener("error", onError);
+	}
+	sb.addEventListener("updateend", onUpdateEnd);
+	sb.addEventListener("error", onError);
+	return {
+		enqueue(op) {
+			if (destroyed) return;
+			ops.push(op);
+			pump();
+		},
+		enqueueFront(op) {
+			if (destroyed) return;
+			ops.unshift(op);
+			pump();
+		},
+		abort() {
+			if (destroyed) return;
+			ops.length = 0;
+			quotaAttempts = 0;
+			try {
+				sb.abort();
+			} catch (_unused2) {}
+		},
+		destroy,
+		idle: () => !destroyed && ops.length === 0 && !sb.updating
+	};
+}
+//#endregion
+export { createAppendQueue };

package/dist/es2015/kernel/bus.js

@@ -0,0 +1,134 @@
+import { createTraceBuffer, digest } from "./trace.js";
+//#region src/kernel/bus.ts
+function createBus(options) {
+	var _options$now, _options$traceCapacit;
+	let reducer = options.reducer;
+	const now = (_options$now = options.now) !== null && _options$now !== void 0 ? _options$now : (() => globalThis.performance.now());
+	const traceBuffer = createTraceBuffer((_options$traceCapacit = options.traceCapacity) !== null && _options$traceCapacit !== void 0 ? _options$traceCapacit : 500);
+	let state = options.initial;
+	let effectSink = () => void 0;
+	const queue = [];
+	let processing = false;
+	const listeners = /* @__PURE__ */ new Map();
+	const capabilities = [];
+	const sinks = /* @__PURE__ */ new Map();
+	const parsers = /* @__PURE__ */ new Map();
+	const transformSteps = [];
+	const namespaceMap = /* @__PURE__ */ new Map();
+	function flush() {
+		if (processing) return;
+		processing = true;
+		try {
+			let msg = queue.shift();
+			while (msg !== void 0) {
+				const [next, effects] = reducer(state, msg);
+				state = next;
+				traceBuffer.push({
+					t: now(),
+					msg,
+					effects,
+					digest: digest(state)
+				});
+				effectSink(effects);
+				msg = queue.shift();
+			}
+		} finally {
+			processing = false;
+		}
+	}
+	function enqueue(msg) {
+		queue.push(msg);
+		flush();
+	}
+	function emitEvent(event, payload) {
+		const set = listeners.get(event);
+		if (set === void 0) return;
+		for (const fn of [...set]) try {
+			fn(payload);
+		} catch (_unused) {}
+	}
+	return {
+		dispatch(cmd) {
+			enqueue(cmd);
+		},
+		absorb(fact) {
+			enqueue(fact);
+		},
+		route(msg) {
+			enqueue(msg);
+		},
+		getState() {
+			return state;
+		},
+		trace() {
+			return traceBuffer.snapshot();
+		},
+		setEffectSink(sink) {
+			effectSink = sink;
+		},
+		setReducer(next) {
+			reducer = next;
+		},
+		on(event, fn) {
+			let set = listeners.get(event);
+			if (set === void 0) {
+				set = /* @__PURE__ */ new Set();
+				listeners.set(event, set);
+			}
+			set.add(fn);
+			return () => {
+				set.delete(fn);
+			};
+		},
+		emitEvent,
+		registerCapability(capability) {
+			capabilities.push(capability);
+		},
+		capabilities() {
+			return [...capabilities];
+		},
+		registerSink(contentType, factory) {
+			if (sinks.has(contentType)) throw new Error(`duplicate sink for '${contentType}'`);
+			sinks.set(contentType, factory);
+		},
+		unregisterSink(contentType) {
+			sinks.delete(contentType);
+		},
+		sinkFor(contentType) {
+			return sinks.get(contentType);
+		},
+		registerParser(mimeType, parse) {
+			if (parsers.has(mimeType)) throw new Error(`duplicate parser for '${mimeType}'`);
+			parsers.set(mimeType, parse);
+		},
+		unregisterParser(mimeType) {
+			parsers.delete(mimeType);
+		},
+		parserFor(mimeType) {
+			return parsers.get(mimeType);
+		},
+		registerTransform(step) {
+			transformSteps.push(step);
+			transformSteps.sort((a, b) => a.order - b.order);
+		},
+		unregisterTransform(step) {
+			const index = transformSteps.indexOf(step);
+			if (index >= 0) transformSteps.splice(index, 1);
+		},
+		transforms() {
+			return [...transformSteps];
+		},
+		registerNamespace(name, api) {
+			if (namespaceMap.has(name)) throw new Error(`duplicate namespace '${name}'`);
+			namespaceMap.set(name, api);
+		},
+		unregisterNamespace(name) {
+			namespaceMap.delete(name);
+		},
+		namespaces() {
+			return namespaceMap;
+		}
+	};
+}
+//#endregion
+export { createBus };

package/dist/es2015/kernel/context.js

@@ -0,0 +1,92 @@
+//#region src/kernel/context.ts
+/**
+* Builds one stage's context and returns the registrations' own teardown,
+* combined by the caller with whatever the stage's install returns.
+*/
+function createStageContext(deps) {
+	const unsubscribes = [];
+	const namespaceNames = [];
+	const sinkTypes = [];
+	const parserTypes = [];
+	const transformSteps = [];
+	let registeredChooser = false;
+	let registeredPolicy = false;
+	let registeredProbe = false;
+	return {
+		ctx: {
+			element: deps.element,
+			registerSink(contentType, factory) {
+				deps.bus.registerSink(contentType, factory);
+				sinkTypes.push(contentType);
+			},
+			registerParser(mimeType, parse) {
+				deps.bus.registerParser(mimeType, parse);
+				parserTypes.push(mimeType);
+			},
+			registerTransform(step) {
+				deps.bus.registerTransform(step);
+				transformSteps.push(step);
+			},
+			getState() {
+				return deps.bus.getState();
+			},
+			addRequestHook(hook) {
+				const off = deps.addRequestHook(hook);
+				unsubscribes.push(off);
+				return off;
+			},
+			request(url, init) {
+				return deps.request(url, init);
+			},
+			registerNamespace(name, api) {
+				deps.bus.registerNamespace(name, api);
+				deps.facade[name] = api;
+				namespaceNames.push(name);
+			},
+			registerChooser(chooser) {
+				if (deps.hooks.abr != null) throw new Error("an abr chooser is already registered");
+				deps.hooks.abr = chooser;
+				registeredChooser = true;
+			},
+			registerSwitchPolicy(policy) {
+				if (deps.hooks.switchPolicy != null) throw new Error("a switch policy is already registered");
+				deps.hooks.switchPolicy = policy;
+				registeredPolicy = true;
+			},
+			registerTypeProbe(probe) {
+				if (deps.hooks.typeProbe != null) throw new Error("a type probe is already registered");
+				deps.hooks.typeProbe = probe;
+				registeredProbe = true;
+			},
+			reduce(slice, reducer) {
+				deps.slices.push([slice, reducer]);
+			},
+			dispatch(cmd) {
+				deps.bus.dispatch(cmd);
+			},
+			emit(event, payload) {
+				deps.bus.emitEvent(event, payload);
+			},
+			on(event, fn) {
+				const off = deps.bus.on(event, fn);
+				unsubscribes.push(off);
+				return off;
+			}
+		},
+		teardown() {
+			for (const off of unsubscribes) off();
+			for (const name of namespaceNames) {
+				delete deps.facade[name];
+				deps.bus.unregisterNamespace(name);
+			}
+			for (const contentType of sinkTypes) deps.bus.unregisterSink(contentType);
+			for (const mimeType of parserTypes) deps.bus.unregisterParser(mimeType);
+			for (const step of transformSteps) deps.bus.unregisterTransform(step);
+			if (registeredChooser) deps.hooks.abr = null;
+			if (registeredPolicy) deps.hooks.switchPolicy = null;
+			if (registeredProbe) deps.hooks.typeProbe = null;
+		}
+	};
+}
+//#endregion
+export { createStageContext };

package/dist/es2015/kernel/effects.js

@@ -0,0 +1,62 @@
+//#region src/kernel/effects.ts
+function createEffectRunner(options = {}) {
+	var _options$onEvent;
+	const onEvent = (_options$onEvent = options.onEvent) !== null && _options$onEvent !== void 0 ? _options$onEvent : (() => void 0);
+	const handlers = /* @__PURE__ */ new Map();
+	const cancels = /* @__PURE__ */ new Map();
+	function cancel(token) {
+		const fn = cancels.get(token);
+		if (fn === void 0) return;
+		cancels.delete(token);
+		try {
+			fn();
+		} catch (err) {
+			onEvent("kernel:effect-error", {
+				kind: "abort",
+				message: String(err)
+			});
+		}
+	}
+	return {
+		register(kind, handler) {
+			if (handlers.has(kind)) throw new Error(`duplicate handler for '${kind}'`);
+			handlers.set(kind, handler);
+		},
+		run(effects) {
+			for (const effect of effects) {
+				if (effect.kind === "abort") {
+					var _handlers$get;
+					cancel(effect.token);
+					(_handlers$get = handlers.get("abort")) === null || _handlers$get === void 0 || _handlers$get(effect);
+					continue;
+				}
+				const handler = handlers.get(effect.kind);
+				if (handler === void 0) {
+					onEvent("kernel:effect-unhandled", { kind: effect.kind });
+					continue;
+				}
+				try {
+					const cancelFn = handler(effect);
+					if (cancelFn !== void 0 && "token" in effect) cancels.set(effect.token, cancelFn);
+				} catch (err) {
+					onEvent("kernel:effect-error", {
+						kind: effect.kind,
+						message: String(err)
+					});
+				}
+			}
+		},
+		cancel,
+		forget(token) {
+			cancels.delete(token);
+		},
+		cancelAll() {
+			for (const token of [...cancels.keys()]) cancel(token);
+		},
+		pending() {
+			return [...cancels.keys()];
+		}
+	};
+}
+//#endregion
+export { createEffectRunner };

package/dist/es2015/kernel/evictor.js

@@ -0,0 +1,67 @@
+//#region src/kernel/evictor.ts
+const DEFAULT_BACK_BUFFER = 30;
+const DEFAULT_MAX_PASSES = 3;
+/** Seconds behind the playhead that are never removed. */
+const KEEPOUT_BEHIND_SECONDS = 1;
+/** Seconds ahead of the playhead kept when the last pass drops forward buffer. */
+const FORWARD_KEEP_SECONDS = 10;
+function createEvictor(options = {}) {
+	var _options$backBufferSe, _options$maxPasses;
+	const backBuffer = (_options$backBufferSe = options.backBufferSeconds) !== null && _options$backBufferSe !== void 0 ? _options$backBufferSe : DEFAULT_BACK_BUFFER;
+	const maxPasses = (_options$maxPasses = options.maxPasses) !== null && _options$maxPasses !== void 0 ? _options$maxPasses : DEFAULT_MAX_PASSES;
+	let streaming = true;
+	function clamp(_sb, start, end, currentTime) {
+		if (end === Number.POSITIVE_INFINITY) return {
+			start,
+			end
+		};
+		const clampedEnd = Math.min(end, currentTime - KEEPOUT_BEHIND_SECONDS);
+		if (clampedEnd <= start) return null;
+		return {
+			start,
+			end: clampedEnd
+		};
+	}
+	function overlapsBuffered(sb, entry) {
+		const { buffered } = sb;
+		for (let i = 0; i < buffered.length; i += 1) if (entry.start < buffered.end(i) && entry.end > buffered.start(i)) return true;
+		return false;
+	}
+	return {
+		clamp,
+		plan(sb, currentTime, attempt) {
+			if (attempt > maxPasses) return null;
+			const entries = [];
+			const behind = clamp(sb, 0, currentTime - (attempt === 1 ? backBuffer : attempt === 2 ? backBuffer / 4 : KEEPOUT_BEHIND_SECONDS), currentTime);
+			if (behind !== null) entries.push(behind);
+			if (attempt >= 3) {
+				const aheadStart = currentTime + FORWARD_KEEP_SECONDS;
+				const { buffered } = sb;
+				const bufferedEnd = buffered.length > 0 ? buffered.end(buffered.length - 1) : 0;
+				if (bufferedEnd > aheadStart) entries.push({
+					start: aheadStart,
+					end: bufferedEnd
+				});
+			}
+			return entries.filter((entry) => overlapsBuffered(sb, entry));
+		},
+		observeManaged(ms, onTrim) {
+			const onStart = () => {
+				streaming = true;
+			};
+			const onEnd = () => {
+				streaming = false;
+				onTrim();
+			};
+			ms.addEventListener("startstreaming", onStart);
+			ms.addEventListener("endstreaming", onEnd);
+			return () => {
+				ms.removeEventListener("startstreaming", onStart);
+				ms.removeEventListener("endstreaming", onEnd);
+			};
+		},
+		streaming: () => streaming
+	};
+}
+//#endregion
+export { createEvictor };

package/dist/es2015/kernel/lifecycle.js

@@ -0,0 +1,122 @@
+import { createStageContext } from "./context.js";
+import { createReducer } from "./reducer.js";
+import { createPlaybackWatchdog } from "./watchdog.js";
+//#region src/kernel/lifecycle.ts
+function snapshot(ranges) {
+	const out = [];
+	for (let i = 0; i < ranges.length; i += 1) out.push({
+		start: ranges.start(i),
+		end: ranges.end(i)
+	});
+	return out;
+}
+function createLifecycle(deps) {
+	let element = null;
+	let teardowns = [];
+	let stopWatchdog = null;
+	const elementListeners = [];
+	function listen(el, type, fn) {
+		el.addEventListener(type, fn);
+		elementListeners.push({
+			type,
+			fn
+		});
+	}
+	function attach(el) {
+		if (element !== null) throw Object.assign(/* @__PURE__ */ new Error("this engine is already attached"), {
+			category: "config",
+			code: "CONFIG_ELEMENT_OCCUPIED"
+		});
+		const slices = [];
+		const stageTeardowns = [];
+		for (const stage of deps.composition.order) {
+			const { ctx, teardown } = createStageContext({
+				bus: deps.bus,
+				element: el,
+				facade: deps.facade,
+				slices,
+				hooks: deps.hooks,
+				addRequestHook: deps.addRequestHook,
+				request: deps.request
+			});
+			const returned = stage.install(ctx);
+			if (typeof returned === "function") stageTeardowns.push(returned);
+			stageTeardowns.push(teardown);
+		}
+		deps.bus.setReducer(createReducer(slices, deps.config, deps.hooks));
+		teardowns = stageTeardowns;
+		deps.bus.dispatch({
+			type: "ATTACH",
+			element: el
+		});
+		try {
+			deps.mse.attach(el);
+		} catch (err) {
+			for (const fn of [...teardowns].reverse()) fn();
+			teardowns = [];
+			deps.bus.dispatch({ type: "DETACH" });
+			throw err;
+		}
+		element = el;
+		const absorb = (fact) => deps.bus.absorb(fact);
+		listen(el, "timeupdate", () => {
+			absorb({
+				type: "TIME_UPDATE",
+				currentTime: el.currentTime,
+				buffered: snapshot(el.buffered),
+				wallClock: Date.now() / 1e3
+			});
+		});
+		listen(el, "ended", () => {
+			absorb({
+				type: "ENDED",
+				at: el.currentTime
+			});
+		});
+		listen(el, "seeking", () => {
+			absorb({
+				type: "SEEKING",
+				to: el.currentTime
+			});
+		});
+		listen(el, "seeked", () => {
+			absorb({
+				type: "SEEKED",
+				at: el.currentTime
+			});
+		});
+		listen(el, "waiting", () => {
+			absorb({
+				type: "STALLED",
+				at: el.currentTime
+			});
+		});
+		listen(el, "error", () => {
+			var _deps$onMediaError;
+			(_deps$onMediaError = deps.onMediaError) === null || _deps$onMediaError === void 0 || _deps$onMediaError.call(deps, el);
+		});
+		stopWatchdog = createPlaybackWatchdog(el, absorb);
+		deps.register(el);
+	}
+	function detach() {
+		if (element === null) return;
+		const el = element;
+		deps.bus.dispatch({ type: "DETACH" });
+		stopWatchdog === null || stopWatchdog === void 0 || stopWatchdog();
+		stopWatchdog = null;
+		for (const fn of [...teardowns].reverse()) fn();
+		teardowns = [];
+		deps.mse.detach();
+		for (const { type, fn } of elementListeners) el.removeEventListener(type, fn);
+		elementListeners.length = 0;
+		deps.unregister(el);
+		element = null;
+	}
+	return {
+		attach,
+		detach,
+		element: () => element
+	};
+}
+//#endregion
+export { createLifecycle };