@therealtinhtute/baroiplayer 1.1.0 → 1.2.1

package/dist/core-plugins-CqCxLkbd.js

@@ -0,0 +1,754 @@
+import { r as e } from "./context-DD_SH4tT.js";
+import { _ as t } from "./core-events-v_mKdj5p.js";
+//#region src/core/plugins/types.ts
+var n = class extends Error {
+	constructor(t, n, r, i) {
+		super(`Plugin '${t}' failed during ${n}: ${r}`), e(this, "pluginName", void 0), e(this, "phase", void 0), e(this, "originalError", void 0), this.pluginName = t, this.phase = n, this.originalError = i, this.name = "PluginError";
+	}
+}, r = class extends n {
+	constructor(t, n) {
+		super(t, "initialize", `Missing dependencies: ${n.join(", ")}`), e(this, "missingDependencies", void 0), this.missingDependencies = n, this.name = "PluginDependencyError";
+	}
+}, i = class extends n {
+	constructor(t, n) {
+		super(t, "activate", `Conflicts with active plugins: ${n.join(", ")}`), e(this, "conflictingPlugins", void 0), this.conflictingPlugins = n, this.name = "PluginConflictError";
+	}
+}, a = class {
+	constructor(t = "[Plugin]") {
+		e(this, "prefix", void 0), this.prefix = t;
+	}
+	info(e, t) {
+		t ? console.info(`${this.prefix} ${e}`, t) : console.info(`${this.prefix} ${e}`);
+	}
+	warn(e, t) {
+		t ? console.warn(`${this.prefix} ${e}`, t) : console.warn(`${this.prefix} ${e}`);
+	}
+	error(e, t) {
+		t ? console.error(`${this.prefix} ${e}`, t) : console.error(`${this.prefix} ${e}`);
+	}
+	debug(e, t) {
+		process.env.NODE_ENV === "development" && (t ? console.debug(`${this.prefix} ${e}`, t) : console.debug(`${this.prefix} ${e}`));
+	}
+}, o = class {
+	static validateMetadata(e) {
+		let { metadata: t } = e;
+		if (!t.name || typeof t.name != "string") throw Error("Plugin metadata must include a valid name");
+		if (!t.version || typeof t.version != "string") throw Error("Plugin metadata must include a valid version");
+		if (!t.description || typeof t.description != "string") throw Error("Plugin metadata must include a valid description");
+		if (!t.category) throw Error("Plugin metadata must include a valid category");
+		if (!t.priority) throw Error("Plugin metadata must include a valid priority");
+		return !0;
+	}
+	static validateConfig(e, t) {
+		if (!t) return !0;
+		for (let [n, r] of Object.entries(t)) {
+			let t = e[n];
+			if (r.required && t == null) throw Error(`Configuration property '${n}' is required`);
+			if (t !== void 0 && r.type && typeof t !== r.type) throw Error(`Configuration property '${n}' must be of type '${r.type}'`);
+			if (r.enum && !r.enum.includes(t)) throw Error(`Configuration property '${n}' must be one of: ${r.enum.join(", ")}`);
+			if (r.min !== void 0 && typeof t == "number" && t < r.min) throw Error(`Configuration property '${n}' must be at least ${r.min}`);
+			if (r.max !== void 0 && typeof t == "number" && t > r.max) throw Error(`Configuration property '${n}' must be at most ${r.max}`);
+		}
+		return !0;
+	}
+}, s = class {
+	constructor() {
+		e(this, "metrics", /* @__PURE__ */ new Map());
+	}
+	measure(e, t, n) {
+		let r = `${e}.${t}`, i = performance.now(), a = () => {
+			let e = performance.now(), t = e - i, n = this.metrics.get(r) || {
+				calls: 0,
+				totalTime: 0,
+				averageTime: 0,
+				lastCall: 0
+			};
+			n.calls++, n.totalTime += t, n.averageTime = n.totalTime / n.calls, n.lastCall = e, this.metrics.set(r, n);
+		}, o = n();
+		return o instanceof Promise ? o.then((e) => (a(), e), (e) => {
+			throw a(), e;
+		}) : (a(), o);
+	}
+	getMetrics(e) {
+		if (e) {
+			let t = {};
+			for (let [n, r] of this.metrics.entries()) if (n.startsWith(`${e}.`)) {
+				let i = n.substring(e.length + 1);
+				t[i] = r;
+			}
+			return t;
+		}
+		return Object.fromEntries(this.metrics.entries());
+	}
+	reset(e) {
+		if (e) for (let t of this.metrics.keys()) t.startsWith(`${e}.`) && this.metrics.delete(t);
+		else this.metrics.clear();
+	}
+}, c = {
+	createMockContext() {
+		return {
+			state: {
+				isPlaying: !1,
+				currentTime: 0,
+				duration: 0,
+				volume: 1,
+				isMuted: !1,
+				isLoading: !1,
+				error: null
+			},
+			controls: {
+				play: () => Promise.resolve(),
+				pause: () => Promise.resolve(),
+				seek: (e) => Promise.resolve(),
+				setVolume: (e) => Promise.resolve(),
+				mute: () => Promise.resolve(),
+				unmute: () => Promise.resolve(),
+				toggleMute: () => Promise.resolve()
+			},
+			plugins: {
+				get: () => void 0,
+				getAll: () => [],
+				isEnabled: () => !1
+			},
+			emit: () => {},
+			on: () => () => {},
+			element: null,
+			logger: new a("[MockPlugin]")
+		};
+	},
+	createTestPlugin(e, t = {}) {
+		return {
+			metadata: {
+				name: e,
+				version: "1.0.0",
+				description: `Test plugin: ${e}`,
+				category: "ui",
+				priority: "medium"
+			},
+			initialize: async () => {},
+			activate: async () => {},
+			deactivate: async () => {},
+			destroy: async () => {},
+			healthCheck: () => !0,
+			...t
+		};
+	},
+	time: {
+		async: async (e, t) => {
+			console.time(e);
+			try {
+				let n = await t();
+				return console.timeEnd(e), n;
+			} catch (t) {
+				throw console.timeEnd(e), t;
+			}
+		},
+		sync: (e, t) => {
+			console.time(e);
+			try {
+				let n = t();
+				return console.timeEnd(e), n;
+			} catch (t) {
+				throw console.timeEnd(e), t;
+			}
+		}
+	}
+}, l = class {
+	constructor(t) {
+		e(this, "prefix", void 0), this.prefix = `baroi-plugin-${t}`;
+	}
+	get(e, t) {
+		try {
+			let n = localStorage.getItem(`${this.prefix}-${e}`);
+			return n ? JSON.parse(n) : t;
+		} catch {
+			return t;
+		}
+	}
+	set(e, t) {
+		try {
+			localStorage.setItem(`${this.prefix}-${e}`, JSON.stringify(t));
+		} catch (t) {
+			console.warn(`Failed to store plugin data for key: ${e}`, t);
+		}
+	}
+	remove(e) {
+		try {
+			localStorage.removeItem(`${this.prefix}-${e}`);
+		} catch (t) {
+			console.warn(`Failed to remove plugin data for key: ${e}`, t);
+		}
+	}
+	clear() {
+		try {
+			Object.keys(localStorage).filter((e) => e.startsWith(`${this.prefix}-`)).forEach((e) => localStorage.removeItem(e));
+		} catch (e) {
+			console.warn("Failed to clear plugin data", e);
+		}
+	}
+}, u = new a(), d = new s(), f = class {
+	constructor(n) {
+		e(this, "plugins", /* @__PURE__ */ new Map()), e(this, "pluginConfigs", /* @__PURE__ */ new Map()), e(this, "pluginContexts", /* @__PURE__ */ new Map()), e(this, "enabledPlugins", /* @__PURE__ */ new Set()), e(this, "eventBus", new t()), e(this, "logger", void 0), this.logger = n || new a("[PluginRegistry]");
+	}
+	register(e, t, r = {}) {
+		let i, a, o = {};
+		try {
+			if (typeof e == "string") i = e, a = t, o = r;
+			else {
+				let n = e;
+				o = t || {}, a = n(o), i = a?.metadata?.name;
+			}
+			if (!i || !a) throw new n("unknown", "initialize", "Invalid plugin registration payload");
+			if (this.plugins.has(i)) throw new n(i, "initialize", "Plugin already registered");
+			this.plugins.set(i, a), this.pluginConfigs.set(i, o), this.logger.info(`Plugin '${i}' registered successfully`), this.eventBus.emit("plugin:registered", {
+				name: i,
+				plugin: a
+			});
+		} catch (e) {
+			let t = i || a?.metadata?.name || "unknown";
+			throw this.logger.error(`Failed to register plugin '${t}'`, e), this.eventBus.emit("plugin:error", {
+				name: t,
+				error: e
+			}), e;
+		}
+	}
+	async unregister(e, t) {
+		let r = this.plugins.get(e);
+		if (!r) throw new n(e, "destroy", "Plugin not found");
+		try {
+			let n = t || this.pluginContexts.get(e) || this.createPluginContext(e);
+			this.enabledPlugins.has(e) && await this.deactivate(e, n), r.isInitialized && await r.destroy(n), this.plugins.delete(e), this.pluginConfigs.delete(e), this.pluginContexts.delete(e), this.enabledPlugins.delete(e), this.logger.info(`Plugin '${e}' unregistered successfully`);
+		} catch (t) {
+			throw this.logger.error(`Failed to unregister plugin '${e}'`, t), t;
+		}
+	}
+	get(e) {
+		return this.plugins.get(e);
+	}
+	has(e) {
+		return this.plugins.has(e);
+	}
+	getAll() {
+		return Array.from(this.plugins.values()).sort(this.sortByPriority);
+	}
+	getByCategory(e) {
+		return this.getAll().filter((t) => t.metadata.category === e);
+	}
+	getActive() {
+		return Array.from(this.enabledPlugins).map((e) => this.plugins.get(e)).filter((e) => !!e).sort(this.sortByPriority);
+	}
+	isEnabled(e) {
+		return this.enabledPlugins.has(e);
+	}
+	async initialize(e, t, r = {}) {
+		let i = this.plugins.get(e);
+		if (!i) throw new n(e, "initialize", "Plugin not found");
+		this.ensureDependenciesExist(e);
+		let a = {
+			...this.pluginConfigs.get(e) || {},
+			...r
+		};
+		this.pluginConfigs.set(e, a), this.pluginContexts.set(e, t);
+		try {
+			await i.initialize(t, a);
+		} catch (t) {
+			throw this.logger.error(`Failed to initialize plugin '${e}'`, t), this.eventBus.emit("plugin:error", {
+				name: e,
+				error: t
+			}), t;
+		}
+	}
+	async activate(e, t) {
+		let r = this.plugins.get(e);
+		if (!r) throw new n(e, "activate", "Plugin not found");
+		this.ensureDependenciesActive(e), this.ensureNoActiveConflicts(e), this.pluginContexts.set(e, t);
+		try {
+			await r.activate(t), this.enabledPlugins.add(e), this.eventBus.emit("plugin:enabled", {
+				name: e,
+				plugin: r
+			});
+		} catch (t) {
+			throw this.logger.error(`Failed to activate plugin '${e}'`, t), this.eventBus.emit("plugin:error", {
+				name: e,
+				error: t
+			}), t;
+		}
+	}
+	async deactivate(e, t) {
+		let r = this.plugins.get(e);
+		if (!r) throw new n(e, "deactivate", "Plugin not found");
+		this.pluginContexts.set(e, t);
+		try {
+			await r.deactivate(t), this.enabledPlugins.delete(e), this.eventBus.emit("plugin:disabled", {
+				name: e,
+				plugin: r
+			});
+		} catch (t) {
+			throw this.logger.error(`Failed to deactivate plugin '${e}'`, t), this.eventBus.emit("plugin:error", {
+				name: e,
+				error: t
+			}), t;
+		}
+	}
+	async initializeAll(e) {
+		this.validateDependencies();
+		let t = this.getAll().map((e) => this.findPluginKey(e)).filter(Boolean);
+		for (let n of t) await this.initialize(n, e);
+	}
+	async activateAll(e) {
+		let t = this.getAll().map((e) => this.findPluginKey(e)).filter(Boolean);
+		for (let n of t) {
+			let t = this.plugins.get(n);
+			t && (t.isInitialized || await this.initialize(n, e), await this.activate(n, e));
+		}
+	}
+	async deactivateAll(e) {
+		let t = this.getAll().map((e) => this.findPluginKey(e)).filter(Boolean).reverse();
+		for (let n of t) this.enabledPlugins.has(n) && await this.deactivate(n, e);
+	}
+	async destroyAll(e) {
+		await this.deactivateAll(e);
+		let t = Array.from(this.plugins.keys());
+		for (let n of t) {
+			let t = this.plugins.get(n);
+			t && t.isInitialized && await t.destroy(e);
+		}
+		this.plugins.clear(), this.pluginConfigs.clear(), this.pluginContexts.clear(), this.enabledPlugins.clear();
+	}
+	validateDependencies() {
+		for (let [e, t] of this.plugins.entries()) {
+			let n = (t.metadata.dependencies || []).filter((e) => !this.plugins.has(e));
+			if (n.length > 0) throw new r(e, n);
+		}
+		let e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), i = (r) => {
+			if (e.has(r)) return;
+			if (t.has(r)) throw new n(r, "initialize", "Circular dependency detected");
+			t.add(r);
+			let a = this.plugins.get(r);
+			if (a) {
+				for (let e of a.metadata.dependencies || []) i(e);
+				t.delete(r), e.add(r);
+			}
+		};
+		for (let e of this.plugins.keys()) i(e);
+	}
+	validateConflicts() {
+		for (let [e, t] of this.plugins.entries()) {
+			let n = (t.metadata.conflicts || []).filter((e) => this.plugins.has(e));
+			if (n.length > 0) throw new i(e, n);
+		}
+	}
+	healthCheck(e) {
+		if (typeof e == "string") {
+			let t = this.plugins.get(e);
+			if (!t) return !1;
+			try {
+				let e = t.onInitializeCalled;
+				return typeof e == "boolean" ? e : t.healthCheck ? !!t.healthCheck() : typeof t.isInitialized == "boolean" && t.isInitialized;
+			} catch {
+				return !1;
+			}
+		}
+		return this.healthCheckEnabledPlugins();
+	}
+	healthCheckAll() {
+		let e = {};
+		for (let t of this.plugins.keys()) e[t] = this.healthCheck(t);
+		return e;
+	}
+	async enable(e) {
+		let t = this.plugins.get(e);
+		if (!t) throw new n(e, "activate", "Plugin not found");
+		if (this.enabledPlugins.has(e)) {
+			this.logger.warn(`Plugin '${e}' is already enabled`);
+			return;
+		}
+		let r = this.pluginContexts.get(e) || this.createPluginContext(e);
+		t.isInitialized || await this.initialize(e, r), await this.activate(e, r);
+	}
+	async disable(e) {
+		let t = this.plugins.get(e);
+		if (!t) throw new n(e, "deactivate", "Plugin not found");
+		if (!this.enabledPlugins.has(e)) {
+			this.logger.warn(`Plugin '${e}' is already disabled`);
+			return;
+		}
+		let r = this.pluginContexts.get(e) || this.createPluginContext(e);
+		await this.deactivate(e, r), await t.destroy(r);
+	}
+	async configure(e, t) {
+		let r = this.plugins.get(e);
+		if (!r) throw new n(e, "initialize", "Plugin not found");
+		try {
+			this.pluginConfigs.set(e, {
+				...this.pluginConfigs.get(e),
+				...t
+			}), r.configure && await r.configure(t), this.logger.info(`Plugin '${e}' configured successfully`), this.eventBus.emit("plugin:configured", {
+				name: e,
+				config: t
+			});
+		} catch (t) {
+			throw this.logger.error(`Failed to configure plugin '${e}'`, t), this.eventBus.emit("plugin:error", {
+				name: e,
+				error: t
+			}), t;
+		}
+	}
+	async enablePlugins(e) {
+		let t = this.resolveDependencies(e);
+		for (let e of t) this.enabledPlugins.has(e) || await this.enable(e);
+	}
+	async disablePlugins(e) {
+		let t = [...e].reverse();
+		for (let e of t) this.enabledPlugins.has(e) && await this.disable(e);
+	}
+	getEnabledPlugins() {
+		return this.getActive();
+	}
+	on(e, t) {
+		return this.eventBus.on(e, t), () => this.eventBus.off(e, t);
+	}
+	async healthCheckEnabledPlugins() {
+		let e = [];
+		for (let t of this.enabledPlugins) {
+			let n = this.plugins.get(t);
+			if (n) try {
+				let r = !n.healthCheck || n.healthCheck(), i = r instanceof Promise ? await r : !!r;
+				e.push({
+					name: t,
+					healthy: i
+				});
+			} catch (n) {
+				e.push({
+					name: t,
+					healthy: !1,
+					error: n
+				});
+			}
+		}
+		return e;
+	}
+	findPluginKey(e) {
+		for (let [t, n] of this.plugins.entries()) if (n === e) return t;
+	}
+	ensureDependenciesExist(e) {
+		let t = this.plugins.get(e);
+		if (!t) return;
+		let n = (t.metadata.dependencies || []).filter((e) => !this.plugins.has(e));
+		if (n.length > 0) throw new r(e, n);
+	}
+	ensureDependenciesActive(e) {
+		let t = this.plugins.get(e);
+		if (!t) return;
+		let n = (t.metadata.dependencies || []).filter((e) => !this.enabledPlugins.has(e));
+		if (n.length > 0) throw new r(e, n);
+	}
+	ensureNoActiveConflicts(e) {
+		let t = this.plugins.get(e);
+		if (!t) return;
+		let n = (t.metadata.conflicts || []).filter((e) => this.enabledPlugins.has(e));
+		if (n.length > 0) throw new i(e, n);
+	}
+	createPluginContext(e) {
+		return {
+			state: {},
+			controls: {},
+			plugins: this,
+			emit: (e, t) => this.eventBus.emit(e, t),
+			on: (e, t) => (this.eventBus.on(e, t), () => this.eventBus.off(e, t)),
+			element: null,
+			logger: this.createPluginLogger(e)
+		};
+	}
+	createPluginLogger(e) {
+		return {
+			info: (t, n) => this.logger.info(`[${e}] ${t}`, n),
+			warn: (t, n) => this.logger.warn(`[${e}] ${t}`, n),
+			error: (t, n) => this.logger.error(`[${e}] ${t}`, n),
+			debug: (t, n) => this.logger.debug(`[${e}] ${t}`, n)
+		};
+	}
+	resolveDependencies(e) {
+		let t = [], r = /* @__PURE__ */ new Set(), i = (e) => {
+			if (t.includes(e)) return;
+			if (r.has(e)) throw new n(e, "initialize", "Circular dependency detected");
+			r.add(e);
+			let a = this.plugins.get(e);
+			if (!a) throw new n(e, "initialize", "Plugin not found");
+			for (let e of a.metadata.dependencies || []) i(e);
+			r.delete(e), t.push(e);
+		};
+		for (let t of e) i(t);
+		return t;
+	}
+	sortByPriority(e, t) {
+		let n = {
+			high: 3,
+			medium: 2,
+			normal: 2,
+			low: 1
+		};
+		return (n[t.metadata.priority] || 1) - (n[e.metadata.priority] || 1);
+	}
+}, p = class {
+	constructor(t) {
+		e(this, "metadata", void 0), e(this, "context", void 0), e(this, "config", {}), e(this, "initialized", !1), e(this, "active", !1), this.metadata = {
+			version: "1.0.0",
+			...t
+		};
+	}
+	async initialize(e, t = {}) {
+		if (this.initialized) {
+			e.logger.warn("Plugin already initialized");
+			return;
+		}
+		this.context = e, this.config = {
+			...this.config,
+			...t
+		};
+		try {
+			await this.onInitialize(), this.initialized = !0, e.logger.info("Plugin initialized");
+		} catch (t) {
+			throw e.logger.error("Failed to initialize plugin", t), t;
+		}
+	}
+	async activate(e) {
+		if (!this.initialized) throw Error("Plugin must be initialized before activation");
+		if (this.active) {
+			e.logger.warn("Plugin already active");
+			return;
+		}
+		try {
+			await this.onActivate(), this.active = !0, e.logger.info("Plugin activated");
+		} catch (t) {
+			throw e.logger.error("Failed to activate plugin", t), t;
+		}
+	}
+	async deactivate(e) {
+		if (!this.active) {
+			e.logger.warn("Plugin already inactive");
+			return;
+		}
+		try {
+			await this.onDeactivate(), this.active = !1, e.logger.info("Plugin deactivated");
+		} catch (t) {
+			throw e.logger.error("Failed to deactivate plugin", t), t;
+		}
+	}
+	async destroy(e) {
+		this.active && await this.deactivate(e);
+		try {
+			await this.onDestroy(), this.initialized = !1, e.logger.info("Plugin destroyed");
+		} catch (t) {
+			throw e.logger.error("Failed to destroy plugin", t), t;
+		}
+	}
+	async configure(e) {
+		let t = { ...this.config };
+		this.config = {
+			...this.config,
+			...e
+		};
+		try {
+			await this.onConfigure(e, t), this.context?.logger.info("Plugin configured");
+		} catch (e) {
+			throw this.config = t, this.context?.logger.error("Failed to configure plugin", e), e;
+		}
+	}
+	healthCheck() {
+		return this.initialized && this.onHealthCheck();
+	}
+	onDestroy() {}
+	onConfigure(e, t) {}
+	onHealthCheck() {
+		return !0;
+	}
+	get state() {
+		return this.context?.state;
+	}
+	get controls() {
+		return this.context?.controls;
+	}
+	get element() {
+		return this.context?.element;
+	}
+	get logger() {
+		return this.context?.logger;
+	}
+	emit(e, t) {
+		this.context?.emit(e, t);
+	}
+	on(e, t) {
+		return this.context?.on(e, t) || (() => {});
+	}
+	addEventListeners(e, t) {
+		return Object.entries(t).forEach(([t, n]) => {
+			e.addEventListener(t, n);
+		}), () => {
+			Object.entries(t).forEach(([t, n]) => {
+				e.removeEventListener(t, n);
+			});
+		};
+	}
+	createConfig(e) {
+		return {
+			...e,
+			...this.config
+		};
+	}
+	get isInitialized() {
+		return this.initialized;
+	}
+	get isActive() {
+		return this.active;
+	}
+};
+function m(e) {
+	return (t) => new e(t);
+}
+//#endregion
+//#region src/core/plugins/examples/analytics-plugin.ts
+var h = class extends p {
+	constructor(t) {
+		super({
+			name: "analytics",
+			description: "Media player analytics and tracking",
+			category: "analytics",
+			priority: "low",
+			author: "BaroiPlayer Team"
+		}), e(this, "events", []), e(this, "analyticsConfig", void 0), e(this, "cleanupFunctions", []), e(this, "reportTimer", void 0);
+	}
+	onInitialize() {
+		if (this.analyticsConfig = this.createConfig({
+			trackingId: "",
+			events: [
+				"play",
+				"pause",
+				"seek",
+				"ended",
+				"error"
+			],
+			samplingRate: 1,
+			debug: !1,
+			endpoint: "/api/analytics"
+		}), !this.analyticsConfig.trackingId) throw Error("Analytics plugin requires a tracking ID");
+		this.logger?.info("Analytics plugin initialized", {
+			trackingId: this.analyticsConfig.trackingId,
+			events: this.analyticsConfig.events
+		});
+	}
+	onActivate() {
+		let e = this.setupMediaEventListeners();
+		this.cleanupFunctions.push(e), this.analyticsConfig.endpoint && (this.reportTimer = setInterval(() => {
+			this.reportEvents();
+		}, 3e4), this.cleanupFunctions.push(() => {
+			this.reportTimer && clearInterval(this.reportTimer);
+		})), this.trackEvent("plugin_activated", { plugin: "analytics" }), this.logger?.info("Analytics tracking started");
+	}
+	onDeactivate() {
+		this.cleanupFunctions.forEach((e) => e()), this.cleanupFunctions = [], this.events.length > 0 && this.reportEvents(), this.trackEvent("plugin_deactivated", { plugin: "analytics" }), this.logger?.info("Analytics tracking stopped");
+	}
+	onConfigure(e) {
+		if (this.analyticsConfig = {
+			...this.analyticsConfig,
+			...e
+		}, e.events) {
+			this.cleanupFunctions.forEach((e) => e()), this.cleanupFunctions = [];
+			let e = this.setupMediaEventListeners();
+			this.cleanupFunctions.push(e);
+		}
+	}
+	setupMediaEventListeners() {
+		let e = [];
+		if (this.analyticsConfig.events.includes("play")) {
+			let t = this.on("media:play", (e) => {
+				this.trackEvent("play", e);
+			});
+			e.push(t);
+		}
+		if (this.analyticsConfig.events.includes("pause")) {
+			let t = this.on("media:pause", (e) => {
+				this.trackEvent("pause", e);
+			});
+			e.push(t);
+		}
+		if (this.analyticsConfig.events.includes("seek")) {
+			let t = this.on("media:seek", (e) => {
+				this.trackEvent("seek", e);
+			});
+			e.push(t);
+		}
+		if (this.analyticsConfig.events.includes("ended")) {
+			let t = this.on("media:ended", (e) => {
+				this.trackEvent("ended", e);
+			});
+			e.push(t);
+		}
+		if (this.analyticsConfig.events.includes("error")) {
+			let t = this.on("media:error", (e) => {
+				this.trackEvent("error", e);
+			});
+			e.push(t);
+		}
+		return () => {
+			e.forEach((e) => e());
+		};
+	}
+	trackEvent(e, t) {
+		if (Math.random() > this.analyticsConfig.samplingRate) return;
+		let n = {
+			event: e,
+			timestamp: Date.now(),
+			data: {
+				...t,
+				trackingId: this.analyticsConfig.trackingId,
+				sessionId: this.generateSessionId(),
+				mediaState: {
+					currentTime: this.state?.currentTime,
+					duration: this.state?.duration,
+					volume: this.state?.volume,
+					isPlaying: this.state?.isPlaying
+				}
+			}
+		};
+		this.events.push(n), this.analyticsConfig.debug && this.logger?.info("Analytics event tracked", n), this.emit("analytics:event", n);
+	}
+	async reportEvents() {
+		if (this.events.length === 0 || !this.analyticsConfig.endpoint) return;
+		let e = [...this.events];
+		this.events = [];
+		try {
+			let t = await fetch(this.analyticsConfig.endpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					trackingId: this.analyticsConfig.trackingId,
+					events: e
+				})
+			});
+			if (!t.ok) throw Error(`Analytics report failed: ${t.status}`);
+			this.analyticsConfig.debug && this.logger?.info(`Reported ${e.length} analytics events`);
+		} catch (t) {
+			this.events.unshift(...e), this.logger?.error("Failed to report analytics events", t);
+		}
+	}
+	generateSessionId() {
+		return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+	}
+	track(e, t) {
+		this.trackEvent(e, t);
+	}
+	getPendingEventsCount() {
+		return this.events.length;
+	}
+	async flush() {
+		await this.reportEvents();
+	}
+	onHealthCheck() {
+		return this.events.length < 1e3;
+	}
+}, g = (e) => new h(e), _ = "1.0.0";
+//#endregion
+export { m as a, c, o as d, d as f, n as g, r as h, p as i, s as l, i as m, h as n, f as o, u as p, g as r, a as s, _ as t, l as u };
+
+//# sourceMappingURL=core-plugins-CqCxLkbd.js.map