@buoy-gg/benchmark 2.1.3 → 2.1.4-beta.1

package/lib/module/benchmarking/BenchmarkStorage.js

@@ -1 +1,227 @@
-"use strict";const STORAGE_PREFIX="@buoy-gg/benchmark",INDEX_KEY=`${STORAGE_PREFIX}/index`,REPORT_KEY_PREFIX=`${STORAGE_PREFIX}/report/`;function getReportKey(t){return`${REPORT_KEY_PREFIX}${t}`}function extractMetadata(t){return{id:t.id,name:t.name,description:t.description,createdAt:t.createdAt,duration:t.duration,batchCount:t.stats.batchCount}}export class BenchmarkStorage{constructor(t){this.storage=t}async saveReport(t){const e=await this.loadIndex(),a=e.findIndex(e=>e.id===t.id);return a>=0?e[a]=extractMetadata(t):e.push(extractMetadata(t)),await Promise.all([this.storage.setItem(getReportKey(t.id),JSON.stringify(t)),this.storage.setItem(INDEX_KEY,JSON.stringify(e))]),extractMetadata(t)}async loadReport(t){try{const e=await this.storage.getItem(getReportKey(t));return e?JSON.parse(e):null}catch(e){return console.error(`[BenchmarkStorage] Error loading report ${t}:`,e),null}}async listReports(){return(await this.loadIndex()).sort((t,e)=>e.createdAt-t.createdAt)}async deleteReport(t){const e=await this.loadIndex(),a=e.findIndex(e=>e.id===t);return!(a<0||(e.splice(a,1),await Promise.all([this.storage.removeItem(getReportKey(t)),this.storage.setItem(INDEX_KEY,JSON.stringify(e))]),0))}async clearAll(){const t=await this.loadIndex();await Promise.all([...t.map(t=>this.storage.removeItem(getReportKey(t.id))),this.storage.removeItem(INDEX_KEY)])}async updateReport(t,e){const a=await this.loadReport(t);return!!a&&(void 0!==e.name&&(a.name=e.name),void 0!==e.description&&(a.description=e.description),await this.saveReport(a),!0)}async getMostRecent(){const t=await this.listReports();return 0===t.length?null:this.loadReport(t[0].id)}async getReportsByName(t){return(await this.loadIndex()).filter(e=>e.name===t).sort((t,e)=>e.createdAt-t.createdAt)}async loadIndex(){try{const t=await this.storage.getItem(INDEX_KEY);return t?JSON.parse(t):[]}catch(t){return console.error("[BenchmarkStorage] Error loading index:",t),[]}}}export function createAsyncStorageAdapter(){try{const t=require("@react-native-async-storage/async-storage").default;return{getItem:e=>t.getItem(e),setItem:(e,a)=>t.setItem(e,a),removeItem:e=>t.removeItem(e)}}catch{return console.warn("[BenchmarkStorage] @react-native-async-storage/async-storage not available. Provide a custom storage adapter."),null}}export function createMemoryStorageAdapter(){const t=new Map;return{getItem:async e=>t.get(e)??null,setItem:async(e,a)=>{t.set(e,a)},removeItem:async e=>{t.delete(e)}}}export default BenchmarkStorage;
+/**
+ * BenchmarkStorage
+ *
+ * Handles persistence of benchmark reports to AsyncStorage.
+ * Provides methods to save, load, list, and delete benchmark reports.
+ *
+ * Storage keys:
+ *   - @benchmark/index: Array of report metadata (id, name, createdAt)
+ *   - @benchmark/report/{id}: Full report data
+ *
+ * @packageDocumentation
+ */
+
+"use strict";
+
+/**
+ * Storage adapter interface - allows for different storage backends
+ */
+
+/**
+ * Metadata for a stored benchmark (stored in index)
+ */
+
+// Storage key prefix
+const STORAGE_PREFIX = "@buoy-gg/benchmark";
+const INDEX_KEY = `${STORAGE_PREFIX}/index`;
+const REPORT_KEY_PREFIX = `${STORAGE_PREFIX}/report/`;
+
+/**
+ * Get the storage key for a report
+ */
+function getReportKey(id) {
+  return `${REPORT_KEY_PREFIX}${id}`;
+}
+
+/**
+ * Extract metadata from a full report
+ */
+function extractMetadata(report) {
+  return {
+    id: report.id,
+    name: report.name,
+    description: report.description,
+    createdAt: report.createdAt,
+    duration: report.duration,
+    batchCount: report.stats.batchCount
+  };
+}
+
+/**
+ * BenchmarkStorage - Manages persistence of benchmark reports
+ */
+export class BenchmarkStorage {
+  /**
+   * Create a new BenchmarkStorage instance
+   * @param storage - Storage adapter (e.g., AsyncStorage)
+   */
+  constructor(storage) {
+    this.storage = storage;
+  }
+
+  /**
+   * Save a benchmark report
+   * @returns The saved report's metadata
+   */
+  async saveReport(report) {
+    // Load current index
+    const index = await this.loadIndex();
+
+    // Check if report already exists
+    const existingIndex = index.findIndex(m => m.id === report.id);
+    if (existingIndex >= 0) {
+      // Update existing entry
+      index[existingIndex] = extractMetadata(report);
+    } else {
+      // Add new entry
+      index.push(extractMetadata(report));
+    }
+
+    // Save report and update index
+    await Promise.all([this.storage.setItem(getReportKey(report.id), JSON.stringify(report)), this.storage.setItem(INDEX_KEY, JSON.stringify(index))]);
+    return extractMetadata(report);
+  }
+
+  /**
+   * Load a benchmark report by ID
+   * @returns The report, or null if not found
+   */
+  async loadReport(id) {
+    try {
+      const data = await this.storage.getItem(getReportKey(id));
+      if (!data) return null;
+      const report = JSON.parse(data);
+      return report;
+    } catch (error) {
+      console.error(`[BenchmarkStorage] Error loading report ${id}:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Load all benchmark metadata (for listing)
+   */
+  async listReports() {
+    const index = await this.loadIndex();
+    // Sort by createdAt descending (newest first)
+    return index.sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Delete a benchmark report
+   * @returns true if deleted, false if not found
+   */
+  async deleteReport(id) {
+    // Load current index
+    const index = await this.loadIndex();
+
+    // Find and remove from index
+    const existingIndex = index.findIndex(m => m.id === id);
+    if (existingIndex < 0) {
+      return false;
+    }
+    index.splice(existingIndex, 1);
+
+    // Remove report and update index
+    await Promise.all([this.storage.removeItem(getReportKey(id)), this.storage.setItem(INDEX_KEY, JSON.stringify(index))]);
+    return true;
+  }
+
+  /**
+   * Delete all benchmark reports
+   */
+  async clearAll() {
+    const index = await this.loadIndex();
+
+    // Delete all reports
+    await Promise.all([...index.map(m => this.storage.removeItem(getReportKey(m.id))), this.storage.removeItem(INDEX_KEY)]);
+  }
+
+  /**
+   * Update a benchmark report's name and/or description
+   * @returns true if updated, false if not found
+   */
+  async updateReport(id, updates) {
+    // Load the report
+    const report = await this.loadReport(id);
+    if (!report) return false;
+
+    // Apply updates
+    if (updates.name !== undefined) {
+      report.name = updates.name;
+    }
+    if (updates.description !== undefined) {
+      report.description = updates.description;
+    }
+
+    // Save updated report (this also updates the index)
+    await this.saveReport(report);
+    return true;
+  }
+
+  /**
+   * Get the most recent report
+   */
+  async getMostRecent() {
+    const reports = await this.listReports();
+    if (reports.length === 0) return null;
+    return this.loadReport(reports[0].id);
+  }
+
+  /**
+   * Get reports by name (for comparing multiple runs of same benchmark)
+   */
+  async getReportsByName(name) {
+    const index = await this.loadIndex();
+    return index.filter(m => m.name === name).sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Load the index of all benchmarks
+   */
+  async loadIndex() {
+    try {
+      const data = await this.storage.getItem(INDEX_KEY);
+      if (!data) return [];
+      return JSON.parse(data);
+    } catch (error) {
+      console.error("[BenchmarkStorage] Error loading index:", error);
+      return [];
+    }
+  }
+}
+
+/**
+ * Create a storage instance using AsyncStorage
+ */
+export function createAsyncStorageAdapter() {
+  try {
+    // Dynamic import to avoid hard dependency on AsyncStorage
+    const AsyncStorage = require("@react-native-async-storage/async-storage").default;
+    return {
+      getItem: key => AsyncStorage.getItem(key),
+      setItem: (key, value) => AsyncStorage.setItem(key, value),
+      removeItem: key => AsyncStorage.removeItem(key)
+    };
+  } catch {
+    console.warn("[BenchmarkStorage] @react-native-async-storage/async-storage not available. " + "Provide a custom storage adapter.");
+    return null;
+  }
+}
+
+/**
+ * In-memory storage adapter (for testing or when AsyncStorage is not available)
+ */
+export function createMemoryStorageAdapter() {
+  const store = new Map();
+  return {
+    getItem: async key => store.get(key) ?? null,
+    setItem: async (key, value) => {
+      store.set(key, value);
+    },
+    removeItem: async key => {
+      store.delete(key);
+    }
+  };
+}
+export default BenchmarkStorage;

package/lib/module/benchmarking/index.js

@@ -1 +1,48 @@
-"use strict";export{BenchmarkRecorder,benchmarkRecorder}from"./BenchmarkRecorder";export{BenchmarkStorage,createAsyncStorageAdapter,createMemoryStorageAdapter}from"./BenchmarkStorage";export{BenchmarkComparator}from"./BenchmarkComparator";
+/**
+ * @buoy-gg/benchmark/benchmarking
+ *
+ * Performance benchmarking system for measuring and comparing
+ * highlight updates performance. Uses the W3C Performance API
+ * for accurate timing measurements.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   benchmarkRecorder,
+ *   BenchmarkStorage,
+ *   BenchmarkComparator,
+ *   createAsyncStorageAdapter,
+ * } from '@buoy-gg/benchmark';
+ *
+ * // Start recording
+ * benchmarkRecorder.startSession({ name: 'MyBenchmark' });
+ *
+ * // ... perform operations ...
+ *
+ * // Stop and get report
+ * const report = benchmarkRecorder.stopSession();
+ *
+ * // Save report
+ * const storage = new BenchmarkStorage(createAsyncStorageAdapter()!);
+ * await storage.saveReport(report);
+ *
+ * // Compare with previous
+ * const previous = await storage.getMostRecent();
+ * if (previous) {
+ *   BenchmarkComparator.quickCompare(previous, report);
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+"use strict";
+
+// Types
+// BenchmarkRecorder
+export { BenchmarkRecorder, benchmarkRecorder } from "./BenchmarkRecorder";
+
+// BenchmarkStorage
+export { BenchmarkStorage, createAsyncStorageAdapter, createMemoryStorageAdapter } from "./BenchmarkStorage";
+// BenchmarkComparator
+export { BenchmarkComparator } from "./BenchmarkComparator";

package/lib/module/benchmarking/types.js

@@ -1 +1,13 @@
-"use strict";
+/**
+ * Benchmarking Types
+ *
+ * Core type definitions for the performance benchmarking system.
+ *
+ * @packageDocumentation
+ */
+
+"use strict";
+
+/**
+ * High-resolution timestamp in milliseconds
+ */