@therealtinhtute/baroiplayer 1.0.7 → 1.1.0

package/dist/core-plugins-CROGvQUy.js

@@ -0,0 +1,686 @@
+var f = Object.defineProperty;
+var p = (r, t, e) => t in r ? f(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var o = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+import { E as y } 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 v extends l {
+  constructor(t, e) {
+    super(t, "initialize", `Missing dependencies: ${e.join(", ")}`), this.missingDependencies = e, this.name = "PluginDependencyError";
+  }
+}
+class w extends l {
+  constructor(t, e) {
+    super(t, "activate", `Conflicts with active plugins: ${e.join(", ")}`), this.conflictingPlugins = e, this.name = "PluginConflictError";
+  }
+}
+class b {
+  constructor(t) {
+    o(this, "plugins", /* @__PURE__ */ new Map());
+    o(this, "pluginConfigs", /* @__PURE__ */ new Map());
+    o(this, "enabledPlugins", /* @__PURE__ */ new Set());
+    o(this, "eventBus", new y());
+    o(this, "logger");
+    this.logger = t;
+  }
+  // Register a plugin factory
+  async register(t, e = {}) {
+    try {
+      const i = t(e), { name: n, dependencies: s = [], conflicts: c = [] } = i.metadata;
+      if (this.plugins.has(n))
+        throw new l(n, "initialize", "Plugin already registered");
+      const u = s.filter((h) => !this.plugins.has(h));
+      if (u.length > 0)
+        throw new v(n, u);
+      const a = c.filter((h) => this.enabledPlugins.has(h));
+      if (a.length > 0)
+        throw new w(n, a);
+      this.plugins.set(n, i), this.pluginConfigs.set(n, e), this.logger.info(`Plugin '${n}' registered successfully`), this.eventBus.emit("plugin:registered", { name: n, plugin: i });
+    } catch (i) {
+      const n = t({}).metadata.name;
+      throw this.logger.error(`Failed to register plugin '${n}'`, i), this.eventBus.emit("plugin:error", { name: n, error: i }), i;
+    }
+  }
+  // Unregister a plugin
+  async unregister(t) {
+    if (!this.plugins.get(t))
+      throw new l(t, "destroy", "Plugin not found");
+    try {
+      this.enabledPlugins.has(t) && await this.disable(t), this.plugins.delete(t), this.pluginConfigs.delete(t), this.logger.info(`Plugin '${t}' unregistered successfully`);
+    } catch (i) {
+      throw this.logger.error(`Failed to unregister plugin '${t}'`, i), i;
+    }
+  }
+  // Get a plugin by name
+  get(t) {
+    return this.plugins.get(t);
+  }
+  // Get all plugins sorted by priority
+  getAll() {
+    return Array.from(this.plugins.values()).sort(this.sortByPriority);
+  }
+  // Check if plugin is enabled
+  isEnabled(t) {
+    return this.enabledPlugins.has(t);
+  }
+  // Enable a plugin
+  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;
+    }
+    try {
+      const i = this.createPluginContext(t), n = this.pluginConfigs.get(t);
+      await e.initialize(i, n), await e.activate(i), this.enabledPlugins.add(t), this.logger.info(`Plugin '${t}' enabled successfully`), this.eventBus.emit("plugin:enabled", { name: t, plugin: e });
+    } catch (i) {
+      throw this.logger.error(`Failed to enable plugin '${t}'`, i), this.eventBus.emit("plugin:error", { name: t, error: i }), i;
+    }
+  }
+  // Disable a plugin
+  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;
+    }
+    try {
+      const i = this.createPluginContext(t);
+      await e.deactivate(i), await e.destroy(i), this.enabledPlugins.delete(t), this.logger.info(`Plugin '${t}' disabled successfully`), this.eventBus.emit("plugin:disabled", { name: t, plugin: e });
+    } catch (i) {
+      throw this.logger.error(`Failed to disable plugin '${t}'`, i), this.eventBus.emit("plugin:error", { name: t, error: i }), i;
+    }
+  }
+  // Configure a plugin
+  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;
+    }
+  }
+  // Enable multiple plugins with dependency resolution
+  async enablePlugins(t) {
+    const e = this.resolveDependencies(t);
+    for (const i of e)
+      this.enabledPlugins.has(i) || await this.enable(i);
+  }
+  // Disable multiple plugins
+  async disablePlugins(t) {
+    const e = [...t].reverse();
+    for (const i of e)
+      this.enabledPlugins.has(i) && await this.disable(i);
+  }
+  // Get enabled plugins
+  getEnabledPlugins() {
+    return Array.from(this.enabledPlugins).map((t) => this.plugins.get(t)).filter(Boolean).sort(this.sortByPriority);
+  }
+  // Health check for all enabled plugins
+  async healthCheck() {
+    const t = [];
+    for (const e of this.enabledPlugins) {
+      const i = this.plugins.get(e);
+      try {
+        const n = i.healthCheck ? await i.healthCheck() : !0;
+        t.push({ name: e, healthy: n });
+      } catch (n) {
+        t.push({ name: e, healthy: !1, error: n });
+      }
+    }
+    return t;
+  }
+  // Event handling
+  on(t, e) {
+    return this.eventBus.on(t, e), () => this.eventBus.off(t, e);
+  }
+  // Create plugin context (will be implemented when we have the full context)
+  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)
+    };
+  }
+  // Create plugin-specific logger
+  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)
+    };
+  }
+  // Resolve plugin dependencies
+  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 c = this.plugins.get(s);
+      if (!c)
+        throw new l(s, "initialize", "Plugin not found");
+      for (const u of c.metadata.dependencies || [])
+        n(u);
+      i.delete(s), e.push(s);
+    };
+    for (const s of t)
+      n(s);
+    return e;
+  }
+  // Sort plugins by priority
+  sortByPriority(t, e) {
+    const i = {
+      high: 3,
+      medium: 2,
+      low: 1
+    };
+    return i[e.metadata.priority] - i[t.metadata.priority];
+  }
+}
+class m {
+  constructor(t) {
+    o(this, "metadata");
+    o(this, "context");
+    o(this, "config", {});
+    o(this, "initialized", !1);
+    o(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 k(r) {
+  return (t) => new r(t);
+}
+class P extends m {
+  constructor(e) {
+    super({
+      name: "analytics",
+      description: "Media player analytics and tracking",
+      category: "analytics",
+      priority: "low",
+      author: "BaroiPlayer Team"
+    });
+    o(this, "events", []);
+    o(this, "analyticsConfig");
+    o(this, "cleanupFunctions", []);
+    o(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 x = (r) => new P(r);
+class d {
+  constructor(t = "[Plugin]") {
+    o(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 z {
+  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 $ {
+  constructor() {
+    o(this, "metrics", /* @__PURE__ */ new Map());
+  }
+  measure(t, e, i) {
+    const n = `${t}.${e}`, s = performance.now(), c = () => {
+      const a = performance.now(), h = a - s, g = this.metrics.get(n) || {
+        calls: 0,
+        totalTime: 0,
+        averageTime: 0,
+        lastCall: 0
+      };
+      g.calls++, g.totalTime += h, g.averageTime = g.totalTime / g.calls, g.lastCall = a, this.metrics.set(n, g);
+    }, u = i();
+    return u instanceof Promise ? u.then(
+      (a) => (c(), a),
+      (a) => {
+        throw c(), a;
+      }
+    ) : (c(), u);
+  }
+  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 F = {
+  // 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 I {
+  constructor(t) {
+    o(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 B = new d(), M = new $(), T = "1.0.0";
+export {
+  P as A,
+  m as B,
+  d as C,
+  b as P,
+  T as a,
+  l as b,
+  v as c,
+  w as d,
+  k as e,
+  x as f,
+  z as g,
+  $ as h,
+  F as i,
+  I as j,
+  B as k,
+  M as l
+};
+//# sourceMappingURL=core-plugins-CROGvQUy.js.map