@therealtinhtute/baroiplayer 1.2.1 → 2.0.0-beta.1

package/src/lib/async-utils.ts

@@ -1,194 +0,0 @@
-/**
- * Async utilities for performance optimization
- * Provides throttle and debounce functions for controlling event frequency
- */
-
-/**
- * Throttle function that ensures a function is only called at most once
- * within a specified time period. Includes options for leading and trailing calls.
- *
- * @param func - The function to throttle
- * @param limit - The time limit in milliseconds
- * @param options - Options for leading/trailing edge calls
- * @returns The throttled function
- *
- * @example
- * // Throttle a click handler to at most once per 250ms
- * const throttledClick = throttle(handleClick, 250);
- *
- * // For timeupdate events with leading edge disabled
- * const throttledUpdate = throttle(handleUpdate, 250, { leading: false });
- */
-export function throttle<T extends (...args: Parameters<T>) => ReturnType<T>>(
-	func: T,
-	limit: number,
-	options: { leading?: boolean; trailing?: boolean } = {
-		leading: true,
-		trailing: true
-	}
-): T {
-	let lastResult: ReturnType<T> | undefined
-	let lastCallTime = 0
-	let timeoutId: ReturnType<typeof setTimeout> | null = null
-	const { leading = true, trailing = true } = options
-
-	return ((...args: Parameters<T>): ReturnType<T> => {
-		const now = Date.now()
-		const remaining = limit - (now - lastCallTime)
-
-		const call = () => {
-			lastCallTime = Date.now()
-			timeoutId = null
-			lastResult = func(...args)
-		}
-
-		if (!lastCallTime) {
-			// First call - respect leading option
-			if (leading) {
-				lastResult = func(...args)
-			}
-			lastCallTime = now
-		} else if (remaining <= 0) {
-			// Time limit reached
-			if (timeoutId) {
-				clearTimeout(timeoutId)
-				timeoutId = null
-			}
-			lastResult = func(...args)
-			lastCallTime = now
-		} else if (trailing && !timeoutId) {
-			// Schedule trailing call
-			timeoutId = setTimeout(() => call(), remaining)
-		}
-
-		return lastResult as ReturnType<T>
-	}) as T
-}
-
-/**
- * Debounce function that delays calling a function until after a specified
- * wait period has elapsed since the last time the debounced function was called.
- *
- * @param func - The function to debounce
- * @param wait - The wait period in milliseconds
- * @param options - Options for immediate invocation
- * @returns The debounced function
- *
- * @example
- * // Debounce a resize handler
- * const debouncedResize = debounce(handleResize, 150);
- *
- * // Debounce with immediate option for form validation
- * const immediateValidate = debounce(validateForm, 300, { immediate: true });
- */
-export function debounce<T extends (...args: Parameters<T>) => ReturnType<T>>(
-	func: T,
-	wait: number,
-	options: { immediate?: boolean } = {}
-): T {
-	let timeoutId: ReturnType<typeof setTimeout> | null = null
-	const { immediate = false } = options
-
-	return ((...args: Parameters<T>): ReturnType<T> => {
-		const call = () => {
-			timeoutId = null
-			return func(...args)
-		}
-
-		const later = () => {
-			timeoutId = null
-			if (!immediate) {
-				return func(...args)
-			}
-		}
-
-		const callNow = immediate && !timeoutId
-		const result = callNow ? func(...args) : undefined
-
-		if (timeoutId) {
-			clearTimeout(timeoutId)
-		}
-
-		timeoutId = setTimeout(immediate ? later : call, wait)
-
-		return result as ReturnType<T>
-	}) as T
-}
-
-/**
- * Creates a throttled callback that only updates the value at most once
- * per interval, but always returns the latest value when called.
- * Useful for UI updates that should be throttled but need to show final state.
- *
- * @param initialValue - The initial value
- * @param limit - The time limit in milliseconds
- * @returns An object with update function and getter functions
- *
- * @example
- * const { update, getThrottledValue, getLatestValue } = createThrottledValue(0, 250);
- */
-export function createThrottledValue<T>(initialValue: T, limit: number) {
-	let latestValue = initialValue
-	let lastUpdateTime = 0
-	let throttledValue = initialValue
-
-	const update = (value: T) => {
-		latestValue = value
-		const now = Date.now()
-		if (now - lastUpdateTime >= limit) {
-			throttledValue = value
-			lastUpdateTime = now
-		}
-	}
-
-	const getThrottledValue = () => throttledValue
-	const getLatestValue = () => latestValue
-	const forceUpdate = () => {
-		throttledValue = latestValue
-		lastUpdateTime = Date.now()
-	}
-
-	return { update, getThrottledValue, getLatestValue, forceUpdate }
-}
-
-/**
- * Batch multiple rapid calls into a single call at the end of the event loop.
- * Useful for React state updates that should be batched.
- *
- * @param func - The function to call with batched arguments
- * @returns A function that batches arguments and calls the original function once
- *
- * @example
- * const batchUpdate = batch((updates) => {
- *   updates.forEach(update => setState(prev => ({ ...prev, ...update })));
- * });
- *
- * // Multiple rapid calls will be batched
- * batchUpdate({ a: 1 });
- * batchUpdate({ a: 2 });
- * batchUpdate({ a: 3 });
- */
-export function batch<T extends (...args: Parameters<T>) => void>(
-	func: (args: Parameters<T>[]) => void
-): (...args: Parameters<T>) => void {
-	let batchedArgs: Parameters<T>[] = []
-	let scheduled = false
-
-	const flush = () => {
-		if (batchedArgs.length > 0) {
-			func(batchedArgs)
-			batchedArgs = []
-		}
-		scheduled = false
-	}
-
-	return (...args: Parameters<T>) => {
-		batchedArgs.push(args)
-		if (!scheduled) {
-			scheduled = true
-			// Use setImmediate/setTimeout pattern for cross-environment compatibility
-			// In browsers this schedules as a macrotask, in tests with fake timers it will fire
-			setTimeout(() => flush(), 0)
-		}
-	}
-}

package/src/lib/deprecation.ts

@@ -1,51 +0,0 @@
-/**
- * Deprecation warning utility
- * Shows console warnings for deprecated components and hooks
- */
-
-const deprecationWarnings = new Set<string>()
-
-export function showDeprecationWarning(
-	itemName: string,
-	replacement: string,
-	version: string = "2.0"
-) {
-	const key = `${itemName}-${replacement}-${version}`
-
-	if (deprecationWarnings.has(key)) {
-		return // Already shown this warning
-	}
-
-	deprecationWarnings.add(key)
-
-	console.warn(
-		`⚠️ [BaroiPlayer] DEPRECATION WARNING: ${itemName} is deprecated and will be removed in v${version}.` +
-			`\n   Please replace it with: ${replacement}` +
-			`\n   See https://github.com/baroi/baroiplayer/blob/main/MIGRATION.md for migration guide.`
-	)
-}
-
-export function createDeprecatedComponent<T>(
-	ComponentName: string,
-	replacement: string,
-	component: T
-): T {
-	const DeprecatedComponent = component as any
-
-	// Add deprecation warning to the component
-	if (typeof DeprecatedComponent === "function") {
-		const originalComponent = DeprecatedComponent
-		const WrappedComponent = function (props: any) {
-			showDeprecationWarning(ComponentName, replacement)
-			return originalComponent(props)
-		}
-
-		// Copy over displayName and other properties
-		Object.setPrototypeOf(WrappedComponent, originalComponent)
-		WrappedComponent.displayName = `Deprecated(${ComponentName})`
-
-		return WrappedComponent as T
-	}
-
-	return component
-}

package/src/lib/format-time.ts

@@ -1,37 +0,0 @@
-/**
- * Formats time in seconds to a human-readable string (MM:SS or HH:MM:SS)
- */
-export function formatTime(seconds: number): string {
-	if (isNaN(seconds) || !isFinite(seconds)) {
-		return "0:00"
-	}
-
-	const hours = Math.floor(seconds / 3600)
-	const minutes = Math.floor((seconds % 3600) / 60)
-	const secs = Math.floor(seconds % 60)
-
-	if (hours > 0) {
-		return `${hours}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`
-	}
-
-	return `${minutes}:${secs.toString().padStart(2, "0")}`
-}
-
-/**
- * Parses a time string (MM:SS or HH:MM:SS) to seconds
- */
-export function parseTime(timeString: string): number {
-	const parts = timeString.split(":").map(Number)
-
-	if (parts.length === 2) {
-		// MM:SS format
-		const [minutes = 0, seconds = 0] = parts
-		return minutes * 60 + seconds
-	} else if (parts.length === 3) {
-		// HH:MM:SS format
-		const [hours = 0, minutes = 0, seconds = 0] = parts
-		return hours * 3600 + minutes * 60 + seconds
-	}
-
-	return 0
-}

package/src/lib/index.ts

@@ -1,4 +0,0 @@
-// Utility functions
-export { formatTime, parseTime } from "./format-time"
-export { cn } from "./utils"
-export { throttle, debounce, createThrottledValue, batch } from "./async-utils"

package/src/lib/utils.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from "clsx"
-import { twMerge } from "tailwind-merge"
-
-export function cn(...inputs: ClassValue[]) {
-	return twMerge(clsx(inputs))
-}