@therealtinhtute/baroiplayer 1.1.0 → 1.2.1

package/dist/core-plugins-CROGvQUy.js

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