@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/src/core/plugins/utils.ts

@@ -1,316 +1,317 @@
-import type { Plugin, PluginLogger, PluginConfig } from './types'
+import type { Plugin, PluginConfig, PluginLogger } from "./types"
 
 // Simple console logger implementation
 export class ConsolePluginLogger implements PluginLogger {
-  private prefix: string
-
-  constructor(prefix = '[Plugin]') {
-    this.prefix = prefix
-  }
-
-  info(message: string, data?: any): void {
-    if (data) {
-      console.info(`${this.prefix} ${message}`, data)
-    } else {
-      console.info(`${this.prefix} ${message}`)
-    }
-  }
-
-  warn(message: string, data?: any): void {
-    if (data) {
-      console.warn(`${this.prefix} ${message}`, data)
-    } else {
-      console.warn(`${this.prefix} ${message}`)
-    }
-  }
-
-  error(message: string, data?: any): void {
-    if (data) {
-      console.error(`${this.prefix} ${message}`, data)
-    } else {
-      console.error(`${this.prefix} ${message}`)
-    }
-  }
-
-  debug(message: string, data?: any): void {
-    if (process.env.NODE_ENV === 'development') {
-      if (data) {
-        console.debug(`${this.prefix} ${message}`, data)
-      } else {
-        console.debug(`${this.prefix} ${message}`)
-      }
-    }
-  }
+	private prefix: string
+
+	constructor(prefix = "[Plugin]") {
+		this.prefix = prefix
+	}
+
+	info(message: string, data?: any): void {
+		if (data) {
+			console.info(`${this.prefix} ${message}`, data)
+		} else {
+			console.info(`${this.prefix} ${message}`)
+		}
+	}
+
+	warn(message: string, data?: any): void {
+		if (data) {
+			console.warn(`${this.prefix} ${message}`, data)
+		} else {
+			console.warn(`${this.prefix} ${message}`)
+		}
+	}
+
+	error(message: string, data?: any): void {
+		if (data) {
+			console.error(`${this.prefix} ${message}`, data)
+		} else {
+			console.error(`${this.prefix} ${message}`)
+		}
+	}
+
+	debug(message: string, data?: any): void {
+		if (process.env.NODE_ENV === "development") {
+			if (data) {
+				console.debug(`${this.prefix} ${message}`, data)
+			} else {
+				console.debug(`${this.prefix} ${message}`)
+			}
+		}
+	}
 }
 
 // Plugin validation utilities
 export class PluginValidator {
-  static validateMetadata(plugin: Plugin): boolean {
-    const { metadata } = plugin
-    
-    if (!metadata.name || typeof metadata.name !== 'string') {
-      throw new Error('Plugin metadata must include a valid name')
-    }
-
-    if (!metadata.version || typeof metadata.version !== 'string') {
-      throw new Error('Plugin metadata must include a valid version')
-    }
-
-    if (!metadata.description || typeof metadata.description !== 'string') {
-      throw new Error('Plugin metadata must include a valid description')
-    }
-
-    if (!metadata.category) {
-      throw new Error('Plugin metadata must include a valid category')
-    }
-
-    if (!metadata.priority) {
-      throw new Error('Plugin metadata must include a valid priority')
-    }
-
-    return true
-  }
-
-  static validateConfig(config: PluginConfig, schema?: Record<string, any>): boolean {
-    if (!schema) return true
-
-    // Simple schema validation - could be enhanced with a proper schema validator
-    for (const [key, rules] of Object.entries(schema)) {
-      const value = config[key]
-
-      if (rules.required && (value === undefined || value === null)) {
-        throw new Error(`Configuration property '${key}' is required`)
-      }
-
-      if (value !== undefined && rules.type && typeof value !== rules.type) {
-        throw new Error(`Configuration property '${key}' must be of type '${rules.type}'`)
-      }
-
-      if (rules.enum && !rules.enum.includes(value)) {
-        throw new Error(`Configuration property '${key}' must be one of: ${rules.enum.join(', ')}`)
-      }
-
-      if (rules.min !== undefined && typeof value === 'number' && value < rules.min) {
-        throw new Error(`Configuration property '${key}' must be at least ${rules.min}`)
-      }
-
-      if (rules.max !== undefined && typeof value === 'number' && value > rules.max) {
-        throw new Error(`Configuration property '${key}' must be at most ${rules.max}`)
-      }
-    }
-
-    return true
-  }
+	static validateMetadata(plugin: Plugin): boolean {
+		const { metadata } = plugin
+
+		if (!metadata.name || typeof metadata.name !== "string") {
+			throw new Error("Plugin metadata must include a valid name")
+		}
+
+		if (!metadata.version || typeof metadata.version !== "string") {
+			throw new Error("Plugin metadata must include a valid version")
+		}
+
+		if (!metadata.description || typeof metadata.description !== "string") {
+			throw new Error("Plugin metadata must include a valid description")
+		}
+
+		if (!metadata.category) {
+			throw new Error("Plugin metadata must include a valid category")
+		}
+
+		if (!metadata.priority) {
+			throw new Error("Plugin metadata must include a valid priority")
+		}
+
+		return true
+	}
+
+	static validateConfig(config: PluginConfig, schema?: Record<string, any>): boolean {
+		if (!schema) return true
+
+		// Simple schema validation - could be enhanced with a proper schema validator
+		for (const [key, rules] of Object.entries(schema)) {
+			const value = config[key]
+
+			if (rules.required && (value === undefined || value === null)) {
+				throw new Error(`Configuration property '${key}' is required`)
+			}
+
+			if (value !== undefined && rules.type && typeof value !== rules.type) {
+				throw new Error(`Configuration property '${key}' must be of type '${rules.type}'`)
+			}
+
+			if (rules.enum && !rules.enum.includes(value)) {
+				throw new Error(`Configuration property '${key}' must be one of: ${rules.enum.join(", ")}`)
+			}
+
+			if (rules.min !== undefined && typeof value === "number" && value < rules.min) {
+				throw new Error(`Configuration property '${key}' must be at least ${rules.min}`)
+			}
+
+			if (rules.max !== undefined && typeof value === "number" && value > rules.max) {
+				throw new Error(`Configuration property '${key}' must be at most ${rules.max}`)
+			}
+		}
+
+		return true
+	}
 }
 
 // Plugin performance monitoring
 export class PluginPerformanceMonitor {
-  private metrics = new Map<string, {
-    calls: number
-    totalTime: number
-    averageTime: number
-    lastCall: number
-  }>()
-
-  measure<T>(pluginName: string, operation: string, fn: () => T | Promise<T>): T | Promise<T> {
-    const key = `${pluginName}.${operation}`
-    const startTime = performance.now()
-
-    const updateMetrics = () => {
-      const endTime = performance.now()
-      const duration = endTime - startTime
-
-      const existing = this.metrics.get(key) || {
-        calls: 0,
-        totalTime: 0,
-        averageTime: 0,
-        lastCall: 0
-      }
-
-      existing.calls++
-      existing.totalTime += duration
-      existing.averageTime = existing.totalTime / existing.calls
-      existing.lastCall = endTime
-
-      this.metrics.set(key, existing)
-    }
-
-    const result = fn()
-
-    if (result instanceof Promise) {
-      return result.then(
-        (value) => {
-          updateMetrics()
-          return value
-        },
-        (error) => {
-          updateMetrics()
-          throw error
-        }
-      )
-    } else {
-      updateMetrics()
-      return result
-    }
-  }
-
-  getMetrics(pluginName?: string) {
-    if (pluginName) {
-      const pluginMetrics: Record<string, any> = {}
-      for (const [key, value] of this.metrics.entries()) {
-        if (key.startsWith(`${pluginName}.`)) {
-          const operation = key.substring(pluginName.length + 1)
-          pluginMetrics[operation] = value
-        }
-      }
-      return pluginMetrics
-    }
-
-    return Object.fromEntries(this.metrics.entries())
-  }
-
-  reset(pluginName?: string): void {
-    if (pluginName) {
-      for (const key of this.metrics.keys()) {
-        if (key.startsWith(`${pluginName}.`)) {
-          this.metrics.delete(key)
-        }
-      }
-    } else {
-      this.metrics.clear()
-    }
-  }
+	private metrics = new Map<
+		string,
+		{
+			calls: number
+			totalTime: number
+			averageTime: number
+			lastCall: number
+		}
+	>()
+
+	measure<T>(pluginName: string, operation: string, fn: () => T | Promise<T>): T | Promise<T> {
+		const key = `${pluginName}.${operation}`
+		const startTime = performance.now()
+
+		const updateMetrics = () => {
+			const endTime = performance.now()
+			const duration = endTime - startTime
+
+			const existing = this.metrics.get(key) || {
+				calls: 0,
+				totalTime: 0,
+				averageTime: 0,
+				lastCall: 0
+			}
+
+			existing.calls++
+			existing.totalTime += duration
+			existing.averageTime = existing.totalTime / existing.calls
+			existing.lastCall = endTime
+
+			this.metrics.set(key, existing)
+		}
+
+		const result = fn()
+
+		if (result instanceof Promise) {
+			return result.then(
+				(value) => {
+					updateMetrics()
+					return value
+				},
+				(error) => {
+					updateMetrics()
+					throw error
+				}
+			)
+		} else {
+			updateMetrics()
+			return result
+		}
+	}
+
+	getMetrics(pluginName?: string) {
+		if (pluginName) {
+			const pluginMetrics: Record<string, any> = {}
+			for (const [key, value] of this.metrics.entries()) {
+				if (key.startsWith(`${pluginName}.`)) {
+					const operation = key.substring(pluginName.length + 1)
+					pluginMetrics[operation] = value
+				}
+			}
+			return pluginMetrics
+		}
+
+		return Object.fromEntries(this.metrics.entries())
+	}
+
+	reset(pluginName?: string): void {
+		if (pluginName) {
+			for (const key of this.metrics.keys()) {
+				if (key.startsWith(`${pluginName}.`)) {
+					this.metrics.delete(key)
+				}
+			}
+		} else {
+			this.metrics.clear()
+		}
+	}
 }
 
 // Plugin development helpers
 export const PluginDevelopmentHelpers = {
-  // Create a mock plugin context for testing
-  createMockContext(): any {
-    return {
-      state: {
-        isPlaying: false,
-        currentTime: 0,
-        duration: 0,
-        volume: 1,
-        isMuted: false,
-        isLoading: false,
-        error: null
-      },
-      controls: {
-        play: () => Promise.resolve(),
-        pause: () => Promise.resolve(),
-        seek: (time: number) => Promise.resolve(),
-        setVolume: (volume: number) => Promise.resolve(),
-        mute: () => Promise.resolve(),
-        unmute: () => Promise.resolve(),
-        toggleMute: () => Promise.resolve()
-      },
-      plugins: {
-        get: () => undefined,
-        getAll: () => [],
-        isEnabled: () => false
-      },
-      emit: () => {},
-      on: () => () => {},
-      element: null,
-      logger: new ConsolePluginLogger('[MockPlugin]')
-    }
-  },
-
-  // Create a test plugin for development
-  createTestPlugin(name: string, hooks: Partial<Plugin> = {}): Plugin {
-    return {
-      metadata: {
-        name,
-        version: '1.0.0',
-        description: `Test plugin: ${name}`,
-        category: 'ui',
-        priority: 'medium'
-      },
-      initialize: async () => {},
-      activate: async () => {},
-      deactivate: async () => {},
-      destroy: async () => {},
-      healthCheck: () => true,
-      ...hooks
-    }
-  },
-
-  // Plugin timing utilities
-  time: {
-    async: async <T>(label: string, fn: () => Promise<T>): Promise<T> => {
-      console.time(label)
-      try {
-        const result = await fn()
-        console.timeEnd(label)
-        return result
-      } catch (error) {
-        console.timeEnd(label)
-        throw error
-      }
-    },
-
-    sync: <T>(label: string, fn: () => T): T => {
-      console.time(label)
-      try {
-        const result = fn()
-        console.timeEnd(label)
-        return result
-      } catch (error) {
-        console.timeEnd(label)
-        throw error
-      }
-    }
-  }
+	// Create a mock plugin context for testing
+	createMockContext(): any {
+		return {
+			state: {
+				isPlaying: false,
+				currentTime: 0,
+				duration: 0,
+				volume: 1,
+				isMuted: false,
+				isLoading: false,
+				error: null
+			},
+			controls: {
+				play: () => Promise.resolve(),
+				pause: () => Promise.resolve(),
+				seek: (time: number) => Promise.resolve(),
+				setVolume: (volume: number) => Promise.resolve(),
+				mute: () => Promise.resolve(),
+				unmute: () => Promise.resolve(),
+				toggleMute: () => Promise.resolve()
+			},
+			plugins: {
+				get: () => undefined,
+				getAll: () => [],
+				isEnabled: () => false
+			},
+			emit: () => {},
+			on: () => () => {},
+			element: null,
+			logger: new ConsolePluginLogger("[MockPlugin]")
+		}
+	},
+
+	// Create a test plugin for development
+	createTestPlugin(name: string, hooks: Partial<Plugin> = {}): Plugin {
+		return {
+			metadata: {
+				name,
+				version: "1.0.0",
+				description: `Test plugin: ${name}`,
+				category: "ui",
+				priority: "medium"
+			},
+			initialize: async () => {},
+			activate: async () => {},
+			deactivate: async () => {},
+			destroy: async () => {},
+			healthCheck: () => true,
+			...hooks
+		}
+	},
+
+	// Plugin timing utilities
+	time: {
+		async: async <T>(label: string, fn: () => Promise<T>): Promise<T> => {
+			console.time(label)
+			try {
+				const result = await fn()
+				console.timeEnd(label)
+				return result
+			} catch (error) {
+				console.timeEnd(label)
+				throw error
+			}
+		},
+
+		sync: <T>(label: string, fn: () => T): T => {
+			console.time(label)
+			try {
+				const result = fn()
+				console.timeEnd(label)
+				return result
+			} catch (error) {
+				console.timeEnd(label)
+				throw error
+			}
+		}
+	}
 }
 
 // Plugin storage utilities for persistent data
 export class PluginStorage {
-  private prefix: string
-
-  constructor(pluginName: string) {
-    this.prefix = `baroi-plugin-${pluginName}`
-  }
-
-  get<T>(key: string, defaultValue?: T): T | undefined {
-    try {
-      const item = localStorage.getItem(`${this.prefix}-${key}`)
-      return item ? JSON.parse(item) as T : defaultValue
-    } catch {
-      return defaultValue
-    }
-  }
-
-  set<T>(key: string, value: T): void {
-    try {
-      localStorage.setItem(`${this.prefix}-${key}`, JSON.stringify(value))
-    } catch (error) {
-      console.warn(`Failed to store plugin data for key: ${key}`, error)
-    }
-  }
-
-  remove(key: string): void {
-    try {
-      localStorage.removeItem(`${this.prefix}-${key}`)
-    } catch (error) {
-      console.warn(`Failed to remove plugin data for key: ${key}`, error)
-    }
-  }
-
-  clear(): void {
-    try {
-      const keys = Object.keys(localStorage).filter(key => 
-        key.startsWith(`${this.prefix}-`)
-      )
-      keys.forEach(key => localStorage.removeItem(key))
-    } catch (error) {
-      console.warn('Failed to clear plugin data', error)
-    }
-  }
+	private prefix: string
+
+	constructor(pluginName: string) {
+		this.prefix = `baroi-plugin-${pluginName}`
+	}
+
+	get<T>(key: string, defaultValue?: T): T | undefined {
+		try {
+			const item = localStorage.getItem(`${this.prefix}-${key}`)
+			return item ? (JSON.parse(item) as T) : defaultValue
+		} catch {
+			return defaultValue
+		}
+	}
+
+	set<T>(key: string, value: T): void {
+		try {
+			localStorage.setItem(`${this.prefix}-${key}`, JSON.stringify(value))
+		} catch (error) {
+			console.warn(`Failed to store plugin data for key: ${key}`, error)
+		}
+	}
+
+	remove(key: string): void {
+		try {
+			localStorage.removeItem(`${this.prefix}-${key}`)
+		} catch (error) {
+			console.warn(`Failed to remove plugin data for key: ${key}`, error)
+		}
+	}
+
+	clear(): void {
+		try {
+			const keys = Object.keys(localStorage).filter((key) => key.startsWith(`${this.prefix}-`))
+			keys.forEach((key) => localStorage.removeItem(key))
+		} catch (error) {
+			console.warn("Failed to clear plugin data", error)
+		}
+	}
 }
 
 // Export default logger instance
 export const defaultPluginLogger = new ConsolePluginLogger()
 
 // Export default performance monitor instance
-export const defaultPerformanceMonitor = new PluginPerformanceMonitor()
+export const defaultPerformanceMonitor = new PluginPerformanceMonitor()