@therealtinhtute/baroiplayer 1.2.0 → 2.0.0-beta.1

package/dist/core-plugins-DSBWcTuX.js

@@ -1,821 +0,0 @@
-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