@rudderstack/integrations-lib 0.2.34 → 0.2.36

package/build/utils/benchmark.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Benchmark utilities for performance testing
+ *
+ * Provides easy-to-use tools for measuring function performance,
+ * memory usage, and creating performance comparisons.
+ *
+ * @example
+ * ```typescript
+ * import { benchmark, createBenchmarkSuite } from './benchmark';
+ *
+ * // Simple benchmark
+ * const result = await benchmark('myFunction', () => myFunction(data));
+ * console.log(`Duration: ${result.duration}ms`);
+ *
+ * // Benchmark suite
+ * const suite = createBenchmarkSuite('Array Operations');
+ * suite.add('native map', () => data.map(x => x * 2));
+ * suite.add('custom map', () => customMap(data, x => x * 2));
+ * await suite.run();
+ * ```
+ */
+/**
+ * Result of a benchmark measurement
+ */
+export type BenchmarkResult = {
+    /** Name of the benchmark */
+    name: string;
+    /** Total duration in milliseconds */
+    duration: number;
+    /** Operations per second */
+    opsPerSecond: number;
+    /** Memory used in bytes (heap difference) */
+    memoryUsed: number;
+    /** Number of iterations run */
+    iterations: number;
+    /** Average duration per iteration in milliseconds */
+    avgDuration: number;
+    /** Standard deviation of durations */
+    stdDev: number;
+    /** Minimum duration observed */
+    minDuration: number;
+    /** Maximum duration observed */
+    maxDuration: number;
+};
+/**
+ * Configuration options for benchmarks
+ */
+export type BenchmarkOptions = {
+    /** Number of iterations to run (default: 1) */
+    iterations?: number;
+    /** Number of warmup runs before measuring (default: 1) */
+    warmupRuns?: number;
+    /** Whether to force garbage collection between runs (default: false) */
+    forceGC?: boolean;
+    /** Whether to measure memory usage (default: true) */
+    measureMemory?: boolean;
+    /** Timeout in milliseconds for the entire benchmark (default: 30000) */
+    timeout?: number;
+};
+/**
+ * Benchmark function type
+ */
+export type BenchmarkFunction<T = unknown> = () => T | Promise<T>;
+/**
+ * Run a benchmark for a single function
+ *
+ * @param name - Name of the benchmark
+ * @param fn - Function to benchmark
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = await benchmark('Array.map', () => {
+ *   return largeArray.map(x => x * 2);
+ * }, { iterations: 10, warmupRuns: 3 });
+ *
+ * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);
+ * ```
+ */
+export declare function benchmark(name: string, fn: BenchmarkFunction, options?: BenchmarkOptions): Promise<BenchmarkResult>;
+/**
+ * Compare multiple functions with the same benchmark configuration
+ *
+ * @param benchmarks - Object with benchmark names and functions
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = await compareBenchmarks({
+ *   'native map': () => data.map(x => x * 2),
+ *   'for loop': () => {
+ *     const result = [];
+ *     for (let i = 0; i < data.length; i++) {
+ *       result.push(data[i] * 2);
+ *     }
+ *     return result;
+ *   }
+ * }, { iterations: 5 });
+ *
+ * results.forEach(result => {
+ *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);
+ * });
+ * ```
+ */
+export declare function compareBenchmarks(benchmarks: Record<string, BenchmarkFunction>, options?: BenchmarkOptions): Promise<BenchmarkResult[]>;
+/**
+ * Benchmark suite for organizing and running multiple related benchmarks
+ */
+export declare class BenchmarkSuite {
+    readonly suiteName: string;
+    private benchmarks;
+    private options;
+    constructor(suiteName: string, options?: BenchmarkOptions);
+    /**
+     * Add a benchmark to the suite
+     *
+     * @param name - Name of the benchmark
+     * @param fn - Function to benchmark
+     * @returns This suite instance for chaining
+     */
+    add(name: string, fn: BenchmarkFunction): this;
+    /**
+     * Run all benchmarks in the suite
+     *
+     * @param customOptions - Override suite options for this run
+     * @returns Promise resolving to array of benchmark results
+     */
+    run(customOptions?: BenchmarkOptions): Promise<BenchmarkResult[]>;
+    /**
+     * Get the number of benchmarks in the suite
+     */
+    get size(): number;
+    /**
+     * Clear all benchmarks from the suite
+     */
+    clear(): this;
+}
+/**
+ * Create a new benchmark suite
+ *
+ * @param suiteName - Name of the benchmark suite
+ * @param options - Default options for all benchmarks in the suite
+ * @returns New BenchmarkSuite instance
+ *
+ * @example
+ * ```typescript
+ * const suite = createBenchmarkSuite('String Operations', {
+ *   iterations: 10,
+ *   warmupRuns: 2
+ * });
+ *
+ * suite
+ *   .add('concat', () => str1 + str2)
+ *   .add('template', () => `${str1}${str2}`)
+ *   .add('join', () => [str1, str2].join(''));
+ *
+ * await suite.run();
+ * ```
+ */
+export declare function createBenchmarkSuite(suiteName: string, options?: BenchmarkOptions): BenchmarkSuite;
+/**
+ * Utility to measure memory usage of a function
+ *
+ * @param fn - Function to measure
+ * @param forceGC - Whether to force garbage collection before measuring
+ * @returns Memory usage in bytes
+ *
+ * @example
+ * ```typescript
+ * const memoryUsed = await measureMemory(() => {
+ *   return new Array(100000).fill(0).map(x => ({ value: x }));
+ * });
+ *
+ * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+ * ```
+ */
+export declare function measureMemory(fn: BenchmarkFunction, forceGC?: boolean): Promise<number>;
+//# sourceMappingURL=benchmark.d.ts.map

package/build/utils/benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/utils/benchmark.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sDAAsD;IACtD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAqBlE;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,iBAAiB,EACrB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CA4E1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC7C,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,EAAE,CAAC,CAM5B;AAED;;GAEG;AACH,qBAAa,cAAc;aAKG,SAAS,EAAE,MAAM;IAJ7C,OAAO,CAAC,UAAU,CAAsD;IAExE,OAAO,CAAC,OAAO,CAAmB;gBAEN,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB;IAI7E;;;;;;OAMG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI;IAK9C;;;;;OAKG;IACG,GAAG,CAAC,aAAa,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAkEvE;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAId;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,gBAAgB,GACzB,cAAc,CAEhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,EAAE,EAAE,iBAAiB,EAAE,OAAO,UAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAU1F"}

package/build/utils/benchmark.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Benchmark utilities for performance testing
+ *
+ * Provides easy-to-use tools for measuring function performance,
+ * memory usage, and creating performance comparisons.
+ *
+ * @example
+ * ```typescript
+ * import { benchmark, createBenchmarkSuite } from './benchmark';
+ *
+ * // Simple benchmark
+ * const result = await benchmark('myFunction', () => myFunction(data));
+ * console.log(`Duration: ${result.duration}ms`);
+ *
+ * // Benchmark suite
+ * const suite = createBenchmarkSuite('Array Operations');
+ * suite.add('native map', () => data.map(x => x * 2));
+ * suite.add('custom map', () => customMap(data, x => x * 2));
+ * await suite.run();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkSuite = void 0;
+exports.benchmark = benchmark;
+exports.compareBenchmarks = compareBenchmarks;
+exports.createBenchmarkSuite = createBenchmarkSuite;
+exports.measureMemory = measureMemory;
+/**
+ * Force garbage collection if available
+ */
+function forceGarbageCollection() {
+    if (typeof global !== 'undefined' && global.gc) {
+        global.gc();
+    }
+}
+/**
+ * Calculate standard deviation of an array of numbers
+ */
+function calculateStdDev(values) {
+    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
+    const squaredDiffs = values.map((val) => (val - mean) ** 2);
+    const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;
+    return Math.sqrt(avgSquaredDiff);
+}
+/**
+ * Run a benchmark for a single function
+ *
+ * @param name - Name of the benchmark
+ * @param fn - Function to benchmark
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to benchmark results
+ *
+ * @example
+ * ```typescript
+ * const result = await benchmark('Array.map', () => {
+ *   return largeArray.map(x => x * 2);
+ * }, { iterations: 10, warmupRuns: 3 });
+ *
+ * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);
+ * ```
+ */
+// eslint-disable-next-line require-await
+async function benchmark(name, fn, options = {}) {
+    const { iterations = 1, warmupRuns = 1, forceGC = false, measureMemory: shouldMeasureMemory = true, timeout = 30000, } = options;
+    // Timeout protection
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`Benchmark "${name}" timed out after ${timeout}ms`)), timeout);
+    });
+    const benchmarkPromise = async () => {
+        // Warmup runs
+        await Promise.all(Array.from({ length: warmupRuns }, async () => {
+            await fn();
+        }));
+        if (forceGC) {
+            forceGarbageCollection();
+        }
+        const durations = [];
+        const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
+        const overallStart = performance.now();
+        // Actual benchmark runs
+        for (let i = 0; i < iterations; i += 1) {
+            if (forceGC && i > 0) {
+                forceGarbageCollection();
+            }
+            const iterationStart = performance.now();
+            // eslint-disable-next-line no-await-in-loop
+            await fn();
+            const iterationEnd = performance.now();
+            durations.push(iterationEnd - iterationStart);
+        }
+        const overallEnd = performance.now();
+        const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;
+        const totalDuration = overallEnd - overallStart;
+        const avgDuration = durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;
+        const minDuration = durations.length > 0 ? Math.min(...durations) : 0;
+        const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;
+        const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;
+        const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;
+        const memoryUsed = endMemory - startMemory;
+        return {
+            name,
+            duration: totalDuration,
+            opsPerSecond,
+            memoryUsed,
+            iterations,
+            avgDuration,
+            stdDev,
+            minDuration,
+            maxDuration,
+        };
+    };
+    return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {
+        clearTimeout(timeoutId);
+    });
+}
+/**
+ * Compare multiple functions with the same benchmark configuration
+ *
+ * @param benchmarks - Object with benchmark names and functions
+ * @param options - Benchmark configuration options
+ * @returns Promise resolving to array of benchmark results
+ *
+ * @example
+ * ```typescript
+ * const results = await compareBenchmarks({
+ *   'native map': () => data.map(x => x * 2),
+ *   'for loop': () => {
+ *     const result = [];
+ *     for (let i = 0; i < data.length; i++) {
+ *       result.push(data[i] * 2);
+ *     }
+ *     return result;
+ *   }
+ * }, { iterations: 5 });
+ *
+ * results.forEach(result => {
+ *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);
+ * });
+ * ```
+ */
+async function compareBenchmarks(benchmarks, options = {}) {
+    const results = await Promise.all(Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)));
+    return results.sort((a, b) => a.avgDuration - b.avgDuration);
+}
+/**
+ * Benchmark suite for organizing and running multiple related benchmarks
+ */
+class BenchmarkSuite {
+    constructor(suiteName, options = {}) {
+        this.suiteName = suiteName;
+        this.benchmarks = [];
+        this.options = options;
+    }
+    /**
+     * Add a benchmark to the suite
+     *
+     * @param name - Name of the benchmark
+     * @param fn - Function to benchmark
+     * @returns This suite instance for chaining
+     */
+    add(name, fn) {
+        this.benchmarks.push({ name, fn });
+        return this;
+    }
+    /**
+     * Run all benchmarks in the suite
+     *
+     * @param customOptions - Override suite options for this run
+     * @returns Promise resolving to array of benchmark results
+     */
+    async run(customOptions) {
+        const options = { ...this.options, ...customOptions };
+        const results = [];
+        // eslint-disable-next-line no-console
+        console.log(`\n🚀 Running benchmark suite: ${this.suiteName}`);
+        // eslint-disable-next-line no-console
+        console.log('='.repeat(60));
+        // eslint-disable-next-line no-restricted-syntax
+        for (const { name, fn } of this.benchmarks) {
+            // eslint-disable-next-line no-console
+            console.log(`\n⏱️  Running: ${name}...`);
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const result = await benchmark(name, fn, options);
+                results.push(result);
+                // eslint-disable-next-line no-console
+                console.log(`   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(0)} ops/sec)`);
+                if (options.measureMemory) {
+                    // eslint-disable-next-line no-console
+                    console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+                }
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        // Summary
+        if (results.length > 1) {
+            // eslint-disable-next-line no-console
+            console.log(`\n📊 Summary (sorted by performance):`);
+            const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);
+            const fastest = sortedResults[0];
+            sortedResults.forEach((result, index) => {
+                const relative = result.avgDuration / fastest.avgDuration;
+                let icon = '  ';
+                if (index === 0)
+                    icon = '🥇';
+                else if (index === 1)
+                    icon = '🥈';
+                else if (index === 2)
+                    icon = '🥉';
+                // eslint-disable-next-line no-console
+                console.log(`   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(2)}ms | ${relative.toFixed(2)}x`);
+            });
+        }
+        // eslint-disable-next-line no-console
+        console.log(`\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\n`);
+        return results;
+    }
+    /**
+     * Get the number of benchmarks in the suite
+     */
+    get size() {
+        return this.benchmarks.length;
+    }
+    /**
+     * Clear all benchmarks from the suite
+     */
+    clear() {
+        this.benchmarks = [];
+        return this;
+    }
+}
+exports.BenchmarkSuite = BenchmarkSuite;
+/**
+ * Create a new benchmark suite
+ *
+ * @param suiteName - Name of the benchmark suite
+ * @param options - Default options for all benchmarks in the suite
+ * @returns New BenchmarkSuite instance
+ *
+ * @example
+ * ```typescript
+ * const suite = createBenchmarkSuite('String Operations', {
+ *   iterations: 10,
+ *   warmupRuns: 2
+ * });
+ *
+ * suite
+ *   .add('concat', () => str1 + str2)
+ *   .add('template', () => `${str1}${str2}`)
+ *   .add('join', () => [str1, str2].join(''));
+ *
+ * await suite.run();
+ * ```
+ */
+function createBenchmarkSuite(suiteName, options) {
+    return new BenchmarkSuite(suiteName, options);
+}
+/**
+ * Utility to measure memory usage of a function
+ *
+ * @param fn - Function to measure
+ * @param forceGC - Whether to force garbage collection before measuring
+ * @returns Memory usage in bytes
+ *
+ * @example
+ * ```typescript
+ * const memoryUsed = await measureMemory(() => {
+ *   return new Array(100000).fill(0).map(x => ({ value: x }));
+ * });
+ *
+ * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+ * ```
+ */
+async function measureMemory(fn, forceGC = true) {
+    if (forceGC) {
+        forceGarbageCollection();
+    }
+    const startMemory = process.memoryUsage().heapUsed;
+    await fn();
+    const endMemory = process.memoryUsage().heapUsed;
+    return endMemory - startMemory;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"benchmark.js","sourceRoot":"","sources":["../../src/utils/benchmark.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Benchmark utilities for performance testing\n *\n * Provides easy-to-use tools for measuring function performance,\n * memory usage, and creating performance comparisons.\n *\n * @example\n * ```typescript\n * import { benchmark, createBenchmarkSuite } from './benchmark';\n *\n * // Simple benchmark\n * const result = await benchmark('myFunction', () => myFunction(data));\n * console.log(`Duration: ${result.duration}ms`);\n *\n * // Benchmark suite\n * const suite = createBenchmarkSuite('Array Operations');\n * suite.add('native map', () => data.map(x => x * 2));\n * suite.add('custom map', () => customMap(data, x => x * 2));\n * await suite.run();\n * ```\n */\n\n/**\n * Result of a benchmark measurement\n */\nexport type BenchmarkResult = {\n  /** Name of the benchmark */\n  name: string;\n  /** Total duration in milliseconds */\n  duration: number;\n  /** Operations per second */\n  opsPerSecond: number;\n  /** Memory used in bytes (heap difference) */\n  memoryUsed: number;\n  /** Number of iterations run */\n  iterations: number;\n  /** Average duration per iteration in milliseconds */\n  avgDuration: number;\n  /** Standard deviation of durations */\n  stdDev: number;\n  /** Minimum duration observed */\n  minDuration: number;\n  /** Maximum duration observed */\n  maxDuration: number;\n};\n\n/**\n * Configuration options for benchmarks\n */\nexport type BenchmarkOptions = {\n  /** Number of iterations to run (default: 1) */\n  iterations?: number;\n  /** Number of warmup runs before measuring (default: 1) */\n  warmupRuns?: number;\n  /** Whether to force garbage collection between runs (default: false) */\n  forceGC?: boolean;\n  /** Whether to measure memory usage (default: true) */\n  measureMemory?: boolean;\n  /** Timeout in milliseconds for the entire benchmark (default: 30000) */\n  timeout?: number;\n};\n\n/**\n * Benchmark function type\n */\nexport type BenchmarkFunction<T = unknown> = () => T | Promise<T>;\n\n/**\n * Force garbage collection if available\n */\nfunction forceGarbageCollection(): void {\n  if (typeof global !== 'undefined' && global.gc) {\n    global.gc();\n  }\n}\n\n/**\n * Calculate standard deviation of an array of numbers\n */\nfunction calculateStdDev(values: number[]): number {\n  const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n  const squaredDiffs = values.map((val) => (val - mean) ** 2);\n  const avgSquaredDiff = squaredDiffs.reduce((sum, val) => sum + val, 0) / values.length;\n  return Math.sqrt(avgSquaredDiff);\n}\n\n/**\n * Run a benchmark for a single function\n *\n * @param name - Name of the benchmark\n * @param fn - Function to benchmark\n * @param options - Benchmark configuration options\n * @returns Promise resolving to benchmark results\n *\n * @example\n * ```typescript\n * const result = await benchmark('Array.map', () => {\n *   return largeArray.map(x => x * 2);\n * }, { iterations: 10, warmupRuns: 3 });\n *\n * console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms avg`);\n * ```\n */\n// eslint-disable-next-line require-await\nexport async function benchmark(\n  name: string,\n  fn: BenchmarkFunction,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult> {\n  const {\n    iterations = 1,\n    warmupRuns = 1,\n    forceGC = false,\n    measureMemory: shouldMeasureMemory = true,\n    timeout = 30000,\n  } = options;\n\n  // Timeout protection\n  let timeoutId: NodeJS.Timeout;\n  const timeoutPromise = new Promise<never>((_, reject) => {\n    timeoutId = setTimeout(\n      () => reject(new Error(`Benchmark \"${name}\" timed out after ${timeout}ms`)),\n      timeout,\n    );\n  });\n\n  const benchmarkPromise = async (): Promise<BenchmarkResult> => {\n    // Warmup runs\n    await Promise.all(\n      Array.from({ length: warmupRuns }, async () => {\n        await fn();\n      }),\n    );\n\n    if (forceGC) {\n      forceGarbageCollection();\n    }\n\n    const durations: number[] = [];\n    const startMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n    const overallStart = performance.now();\n\n    // Actual benchmark runs\n    for (let i = 0; i < iterations; i += 1) {\n      if (forceGC && i > 0) {\n        forceGarbageCollection();\n      }\n\n      const iterationStart = performance.now();\n      // eslint-disable-next-line no-await-in-loop\n      await fn();\n      const iterationEnd = performance.now();\n\n      durations.push(iterationEnd - iterationStart);\n    }\n\n    const overallEnd = performance.now();\n    const endMemory = shouldMeasureMemory ? process.memoryUsage().heapUsed : 0;\n\n    const totalDuration = overallEnd - overallStart;\n    const avgDuration =\n      durations.length > 0 ? durations.reduce((sum, d) => sum + d, 0) / durations.length : 0;\n    const minDuration = durations.length > 0 ? Math.min(...durations) : 0;\n    const maxDuration = durations.length > 0 ? Math.max(...durations) : 0;\n    const stdDev = durations.length > 0 ? calculateStdDev(durations) : 0;\n    const opsPerSecond = totalDuration > 0 ? iterations / (totalDuration / 1000) : 0;\n    const memoryUsed = endMemory - startMemory;\n\n    return {\n      name,\n      duration: totalDuration,\n      opsPerSecond,\n      memoryUsed,\n      iterations,\n      avgDuration,\n      stdDev,\n      minDuration,\n      maxDuration,\n    };\n  };\n\n  return Promise.race([benchmarkPromise(), timeoutPromise]).finally(() => {\n    clearTimeout(timeoutId);\n  });\n}\n\n/**\n * Compare multiple functions with the same benchmark configuration\n *\n * @param benchmarks - Object with benchmark names and functions\n * @param options - Benchmark configuration options\n * @returns Promise resolving to array of benchmark results\n *\n * @example\n * ```typescript\n * const results = await compareBenchmarks({\n *   'native map': () => data.map(x => x * 2),\n *   'for loop': () => {\n *     const result = [];\n *     for (let i = 0; i < data.length; i++) {\n *       result.push(data[i] * 2);\n *     }\n *     return result;\n *   }\n * }, { iterations: 5 });\n *\n * results.forEach(result => {\n *   console.log(`${result.name}: ${result.avgDuration.toFixed(2)}ms`);\n * });\n * ```\n */\nexport async function compareBenchmarks(\n  benchmarks: Record<string, BenchmarkFunction>,\n  options: BenchmarkOptions = {},\n): Promise<BenchmarkResult[]> {\n  const results = await Promise.all(\n    Object.entries(benchmarks).map(([name, fn]) => benchmark(name, fn, options)),\n  );\n\n  return results.sort((a, b) => a.avgDuration - b.avgDuration);\n}\n\n/**\n * Benchmark suite for organizing and running multiple related benchmarks\n */\nexport class BenchmarkSuite {\n  private benchmarks: Array<{ name: string; fn: BenchmarkFunction }> = [];\n\n  private options: BenchmarkOptions;\n\n  constructor(public readonly suiteName: string, options: BenchmarkOptions = {}) {\n    this.options = options;\n  }\n\n  /**\n   * Add a benchmark to the suite\n   *\n   * @param name - Name of the benchmark\n   * @param fn - Function to benchmark\n   * @returns This suite instance for chaining\n   */\n  add(name: string, fn: BenchmarkFunction): this {\n    this.benchmarks.push({ name, fn });\n    return this;\n  }\n\n  /**\n   * Run all benchmarks in the suite\n   *\n   * @param customOptions - Override suite options for this run\n   * @returns Promise resolving to array of benchmark results\n   */\n  async run(customOptions?: BenchmarkOptions): Promise<BenchmarkResult[]> {\n    const options = { ...this.options, ...customOptions };\n    const results: BenchmarkResult[] = [];\n\n    // eslint-disable-next-line no-console\n    console.log(`\\n🚀 Running benchmark suite: ${this.suiteName}`);\n    // eslint-disable-next-line no-console\n    console.log('='.repeat(60));\n\n    // eslint-disable-next-line no-restricted-syntax\n    for (const { name, fn } of this.benchmarks) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n⏱️  Running: ${name}...`);\n\n      try {\n        // eslint-disable-next-line no-await-in-loop\n        const result = await benchmark(name, fn, options);\n        results.push(result);\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ✅ ${result.avgDuration.toFixed(2)}ms avg (${result.opsPerSecond.toFixed(\n            0,\n          )} ops/sec)`,\n        );\n        if (options.measureMemory) {\n          // eslint-disable-next-line no-console\n          console.log(`   💾 Memory: ${(result.memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n        }\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.log(`   ❌ Failed: ${error instanceof Error ? error.message : 'Unknown error'}`);\n      }\n    }\n\n    // Summary\n    if (results.length > 1) {\n      // eslint-disable-next-line no-console\n      console.log(`\\n📊 Summary (sorted by performance):`);\n      const sortedResults = [...results].sort((a, b) => a.avgDuration - b.avgDuration);\n      const fastest = sortedResults[0];\n\n      sortedResults.forEach((result, index) => {\n        const relative = result.avgDuration / fastest.avgDuration;\n        let icon = '  ';\n        if (index === 0) icon = '🥇';\n        else if (index === 1) icon = '🥈';\n        else if (index === 2) icon = '🥉';\n\n        // eslint-disable-next-line no-console\n        console.log(\n          `   ${icon} ${result.name.padEnd(25)} | ${result.avgDuration.toFixed(\n            2,\n          )}ms | ${relative.toFixed(2)}x`,\n        );\n      });\n    }\n\n    // eslint-disable-next-line no-console\n    console.log(\n      `\\n✅ Suite completed: ${results.length}/${this.benchmarks.length} benchmarks successful\\n`,\n    );\n\n    return results;\n  }\n\n  /**\n   * Get the number of benchmarks in the suite\n   */\n  get size(): number {\n    return this.benchmarks.length;\n  }\n\n  /**\n   * Clear all benchmarks from the suite\n   */\n  clear(): this {\n    this.benchmarks = [];\n    return this;\n  }\n}\n\n/**\n * Create a new benchmark suite\n *\n * @param suiteName - Name of the benchmark suite\n * @param options - Default options for all benchmarks in the suite\n * @returns New BenchmarkSuite instance\n *\n * @example\n * ```typescript\n * const suite = createBenchmarkSuite('String Operations', {\n *   iterations: 10,\n *   warmupRuns: 2\n * });\n *\n * suite\n *   .add('concat', () => str1 + str2)\n *   .add('template', () => `${str1}${str2}`)\n *   .add('join', () => [str1, str2].join(''));\n *\n * await suite.run();\n * ```\n */\nexport function createBenchmarkSuite(\n  suiteName: string,\n  options?: BenchmarkOptions,\n): BenchmarkSuite {\n  return new BenchmarkSuite(suiteName, options);\n}\n\n/**\n * Utility to measure memory usage of a function\n *\n * @param fn - Function to measure\n * @param forceGC - Whether to force garbage collection before measuring\n * @returns Memory usage in bytes\n *\n * @example\n * ```typescript\n * const memoryUsed = await measureMemory(() => {\n *   return new Array(100000).fill(0).map(x => ({ value: x }));\n * });\n *\n * console.log(`Memory used: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);\n * ```\n */\nexport async function measureMemory(fn: BenchmarkFunction, forceGC = true): Promise<number> {\n  if (forceGC) {\n    forceGarbageCollection();\n  }\n\n  const startMemory = process.memoryUsage().heapUsed;\n  await fn();\n  const endMemory = process.memoryUsage().heapUsed;\n\n  return endMemory - startMemory;\n}\n"]}

package/build/utils/misc.d.ts

@@ -137,16 +137,33 @@ export declare const generateRandomString: (length?: number) => string;
  */
 export declare const flattenQueryParams: (qParams: Record<string, any | any[]>) => Record<string, any>;
 /**
- * Recursively freezes an object and all its properties.
- * This makes the object and its nested properties immutable.
- *
- * @template T - The type of the object to freeze
- * @param {T} obj - The object to freeze
- * @returns {Readonly<T>} - The frozen object
+ * Locks a property of an object, making it immutable.
+ * @param obj - The object to lock the property of.
+ * @param key - The key of the property to lock.
+ * @returns The object with the property locked.
+ */
+export declare const lockProperty: <T extends object, K extends keyof T>(obj: T, key: K) => T;
+/**
+ * Deep freezes an object, making it immutable.
+ * @param obj - The object to deep freeze.
+ * @returns {T | Readonly<T>} - If `propKey` is provided, returns the original object `T` with `obj[propKey]` deep frozen and `propKey` locked. Otherwise, returns a `Readonly<T>` version of the entire object.
  *
  * @example
  * const config = deepFreeze({ api: { key: 'secret', timeout: 1000 } });
  * // Attempting to modify config.api.key will throw an error in strict mode
  */
-export declare const deepFreeze: <T>(obj: T) => Readonly<T>;
+export declare const deepFreeze: <T extends Record<string, unknown>>(obj: T) => Readonly<T>;
+/**
+ * Deep freezes a specific property of an object and locks that property from reassignment.
+ * @template T - The type of the object.
+ * @param {T} obj - The object containing the property to freeze.
+ * @param {keyof T} propKey - The key of the property to deep freeze and lock.
+ * @returns {T} - The original object `T` with `obj[propKey]` deep frozen and `propKey` locked.
+ *
+ * @example
+ * const myObject = { data: { value: 123 } };
+ * deepFreezeProperty(myObject, 'data');
+ * // myObject.data is now immutable, and myObject.data cannot be reassigned.
+ */
+export declare const deepFreezeProperty: <T extends Record<string, unknown>>(obj: T, propKey: keyof T) => T;
 //# sourceMappingURL=misc.d.ts.map

package/build/utils/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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"}