@geenius/tools 0.1.0 → 0.3.0

package/packages/perf/src/index.ts

@@ -1,410 +0,0 @@
-/**
- * @geenius-tools/perf — Performance monitoring
- *
- * Provides utilities for measuring and tracking performance metrics.
- * Supports timing, memory profiling, and metric collection.
- */
-
-/**
- * Performance metric entry
- */
-export interface PerfMetric {
-  /** Metric name */
-  name: string
-  /** Duration in milliseconds */
-  duration: number
-  /** When metric was recorded */
-  timestamp: Date
-  /** Metric tags */
-  tags?: Record<string, string>
-  /** Additional metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Performance monitor callback
- */
-export type PerfCallback = (metric: PerfMetric) => void | Promise<void>
-
-/**
- * Simple timer for measuring duration
- *
- * @example
- * ```ts
- * const timer = new Timer()
- * // ... do work ...
- * console.log(timer.elapsed()) // duration in ms
- * ```
- */
-export class Timer {
-  private startTime: number
-
-  constructor() {
-    this.startTime = this.now()
-  }
-
-  /**
-   * Gets elapsed time in milliseconds
-   */
-  elapsed(): number {
-    return this.now() - this.startTime
-  }
-
-  /**
-   * Resets timer
-   */
-  reset() {
-    this.startTime = this.now()
-  }
-
-  /**
-   * Gets current time in milliseconds
-   */
-  private now(): number {
-    if (typeof performance !== 'undefined' && performance.now) {
-      return performance.now()
-    }
-    return Date.now()
-  }
-}
-
-/**
- * Performance tracker for named metrics
- *
- * @example
- * ```ts
- * const perf = new PerfTracker()
- * perf.mark('fetch-start')
- * // ... fetch data ...
- * perf.measure('api-call', 'fetch-start')
- * ```
- */
-export class PerfTracker {
-  private marks: Map<string, number> = new Map()
-  private metrics: PerfMetric[] = []
-  private callbacks: PerfCallback[] = []
-
-  /**
-   * Records a performance mark at current time
-   */
-  mark(name: string, tags?: Record<string, string>) {
-    const now = typeof performance !== 'undefined' && performance.now
-      ? performance.now()
-      : Date.now()
-
-    this.marks.set(name, now)
-  }
-
-  /**
-   * Measures duration from mark to now
-   */
-  measure(
-    name: string,
-    startMark: string,
-    endMark?: string,
-    metadata?: Record<string, unknown>
-  ): number {
-    const startTime = this.marks.get(startMark)
-    if (startTime === undefined) {
-      console.warn(`Mark "${startMark}" not found`)
-      return 0
-    }
-
-    let endTime: number
-    if (endMark) {
-      endTime = this.marks.get(endMark) ?? this.now()
-    } else {
-      endTime = this.now()
-    }
-
-    const duration = endTime - startTime
-
-    const metric: PerfMetric = {
-      name,
-      duration,
-      timestamp: new Date(),
-      metadata,
-    }
-
-    this.metrics.push(metric)
-    this.emit(metric)
-
-    return duration
-  }
-
-  /**
-   * Times a function execution
-   *
-   * @example
-   * ```ts
-   * const duration = await perf.time('fetch', async () => {
-   *   return fetch('/api/data')
-   * })
-   * ```
-   */
-  async time<T>(
-    name: string,
-    fn: () => T | Promise<T>,
-    metadata?: Record<string, unknown>
-  ): Promise<{ duration: number; result: T }> {
-    const timer = new Timer()
-
-    try {
-      const result = await Promise.resolve(fn())
-      const duration = timer.elapsed()
-
-      const metric: PerfMetric = {
-        name,
-        duration,
-        timestamp: new Date(),
-        metadata,
-      }
-
-      this.metrics.push(metric)
-      this.emit(metric)
-
-      return { duration, result }
-    } catch (error) {
-      const duration = timer.elapsed()
-      const metric: PerfMetric = {
-        name,
-        duration,
-        timestamp: new Date(),
-        metadata: {
-          ...metadata,
-          error: error instanceof Error ? error.message : String(error),
-        },
-      }
-
-      this.metrics.push(metric)
-      this.emit(metric)
-
-      throw error
-    }
-  }
-
-  /**
-   * Times a sync function execution
-   */
-  timeSync<T>(
-    name: string,
-    fn: () => T,
-    metadata?: Record<string, unknown>
-  ): { duration: number; result: T } {
-    const timer = new Timer()
-
-    try {
-      const result = fn()
-      const duration = timer.elapsed()
-
-      const metric: PerfMetric = {
-        name,
-        duration,
-        timestamp: new Date(),
-        metadata,
-      }
-
-      this.metrics.push(metric)
-      this.emit(metric)
-
-      return { duration, result }
-    } catch (error) {
-      const duration = timer.elapsed()
-      const metric: PerfMetric = {
-        name,
-        duration,
-        timestamp: new Date(),
-        metadata: {
-          ...metadata,
-          error: error instanceof Error ? error.message : String(error),
-        },
-      }
-
-      this.metrics.push(metric)
-      this.emit(metric)
-
-      throw error
-    }
-  }
-
-  /**
-   * Registers callback for metric events
-   */
-  on(callback: PerfCallback) {
-    this.callbacks.push(callback)
-    return () => {
-      this.callbacks = this.callbacks.filter((cb) => cb !== callback)
-    }
-  }
-
-  /**
-   * Emits metric to registered callbacks
-   */
-  private emit(metric: PerfMetric) {
-    for (const callback of this.callbacks) {
-      try {
-        void callback(metric)
-      } catch {
-        // Silently fail to prevent perf tracking from breaking app
-      }
-    }
-  }
-
-  /**
-   * Gets all recorded metrics
-   */
-  getMetrics(): PerfMetric[] {
-    return [...this.metrics]
-  }
-
-  /**
-   * Gets metrics by name
-   */
-  getByName(name: string): PerfMetric[] {
-    return this.metrics.filter((m) => m.name === name)
-  }
-
-  /**
-   * Gets average duration for named metric
-   */
-  getAverage(name: string): number {
-    const metrics = this.getByName(name)
-    if (metrics.length === 0) return 0
-
-    const total = metrics.reduce((sum, m) => sum + m.duration, 0)
-    return total / metrics.length
-  }
-
-  /**
-   * Clears all metrics
-   */
-  clear() {
-    this.marks.clear()
-    this.metrics = []
-  }
-
-  /**
-   * Gets current time in ms
-   */
-  private now(): number {
-    if (typeof performance !== 'undefined' && performance.now) {
-      return performance.now()
-    }
-    return Date.now()
-  }
-}
-
-/**
- * Creates a performance tracker instance
- *
- * @example
- * ```ts
- * const perf = createPerfTracker()
- * await perf.time('api-call', () => fetch('/api/data'))
- * ```
- */
-export function createPerfTracker(): PerfTracker {
-  return new PerfTracker()
-}
-
-/**
- * Measures memory usage (Node.js only)
- *
- * @returns Memory usage in bytes
- */
-export function getMemoryUsage(): {
-  heapUsed: number
-  heapTotal: number
-  external: number
-} {
-  if (typeof process !== 'undefined' && process.memoryUsage) {
-    const usage = process.memoryUsage()
-    return {
-      heapUsed: usage.heapUsed,
-      heapTotal: usage.heapTotal,
-      external: usage.external,
-    }
-  }
-
-  return {
-    heapUsed: 0,
-    heapTotal: 0,
-    external: 0,
-  }
-}
-
-/**
- * Decorator for automatic function timing
- *
- * @example
- * ```ts
- * class DataService {
- *   @Timed()
- *   async fetchData() {
- *     return fetch('/api/data')
- *   }
- * }
- * ```
- */
-export function Timed(name?: string): MethodDecorator {
-  return function (target, prop, descriptor) {
-    if (!descriptor || typeof descriptor.value !== 'function') {
-      return descriptor
-    }
-
-    const originalFn = descriptor.value
-    const metricName = name ?? String(prop)
-    const tracker = createPerfTracker()
-
-    descriptor.value = async function (...args: any[]) {
-      const { duration, result } = await tracker.time(metricName, () =>
-        originalFn.apply(this, args)
-      )
-      return result
-    }
-
-    return descriptor
-  }
-}
-
-/**
- * Debounce function with performance tracking
- */
-export function debounce<T extends (...args: any[]) => any>(
-  fn: T,
-  wait: number,
-  name?: string
-): T {
-  let timeout: NodeJS.Timeout | null = null
-  const tracker = createPerfTracker()
-
-  return ((...args: any[]) => {
-    if (timeout) {
-      clearTimeout(timeout)
-    }
-
-    timeout = setTimeout(() => {
-      void tracker.timeSync(name ?? fn.name, () => fn(...args))
-    }, wait)
-  }) as T
-}
-
-/**
- * Throttle function with performance tracking
- */
-export function throttle<T extends (...args: any[]) => any>(
-  fn: T,
-  wait: number,
-  name?: string
-): T {
-  let last = 0
-  const tracker = createPerfTracker()
-
-  return ((...args: any[]) => {
-    const now = Date.now()
-    if (now - last >= wait) {
-      last = now
-      void tracker.timeSync(name ?? fn.name, () => fn(...args))
-    }
-  }) as T
-}

package/packages/perf/tsup.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-    },
-    format: ['esm'],
-    dts: true,
-    clean: true,
-    sourcemap: true,
-})
-

package/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-packages:
-  - 'packages/*/*'