@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/dist/core-plugins-DSBWcTuX.js

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