lieko-metrics 0.0.1

package/README.md

@@ -0,0 +1,109 @@
+# LiekoMetrics
+
+**Super simple performance measurement helper**  
+Works in **Node.js**, **browsers**, and via **CDN** — zero dependencies.
+
+Measure code execution time with nice console output and human-readable durations (µs, ms, s, min).
+
+## Quick Start
+
+### 1. Node.js / Bun / Deno (CommonJS or ESM)
+
+```js
+// CommonJS
+const perf = require('lieko-metrics');
+
+// or ESM
+import perf from 'lieko-metrics';
+
+perf.start('my-task');
+// ... your code ...
+perf.stop('my-task');
+// → ⏱️  my-task perf: 12.4ms
+```
+
+### 2. Browser – via CDN (recommended)
+
+```html
+<!-- Latest version from jsDelivr -->
+<script src="https://cdn.jsdelivr.net/npm/lieko-metrics@latest/dist/lieko-metrics.min.js"></script>
+
+<!-- Or specific version -->
+<!-- <script src="https://cdn.jsdelivr.net/npm/lieko-metrics@1.0.0/dist/lieko-metrics.min.js"></script> -->
+```
+
+```html
+<script>
+  // Global instance ready to use
+  liekoPerf.start('page-load');
+  // ... your code ...
+  liekoPerf.stop('page-load');
+
+  // Or create your own instance
+  const perf = new LiekoMetrics();
+  perf.start('heavy-computation');
+  // ...
+  perf.stop('heavy-computation');
+  perf.printSummary();
+</script>
+```
+
+## Most useful methods
+
+```js
+perf.start('name')          // begin measuring
+perf.stop('name')           // end + log + save
+perf.printSummary()         // beautiful overview of all measurements
+
+perf.getStats('name')       // → { count, total, average, min, max, latest }
+perf.clear()                // reset everything
+```
+
+## Real-world examples
+
+```js
+// Single shot
+perf.start('render-users');
+renderComplexList(users);
+perf.stop('render-users');
+
+// Multiple runs → great for averages
+for (let i = 0; i < 10; i++) {
+  perf.start('api:fetch-users');
+  await fetch('/api/users');
+  perf.stop('api:fetch-users');
+}
+
+perf.printSummary();
+// Example output:
+// api:fetch-users:
+//   Runs: 10
+//   Avg:   342ms
+//   Min:   281ms
+//   Max:   419ms
+//   Last:  355ms
+```
+
+## Recommended naming style (hierarchical)
+
+```js
+perf.start('page-home:total')
+perf.start('page-home:database:users')
+perf.start('page-home:render:recommendations')
+perf.start('page-home:image:lazy-load')
+
+// Stop in reverse order is a good practice
+```
+
+## Features
+
+- Zero dependencies
+- Works in Node.js **and** modern browsers
+- Human-readable durations (`34µs` → `1m 5.2s`)
+- Automatic console logging with emoji
+- Multi-run statistics (avg/min/max/latest)
+- Global `liekoPerf` instance in browser + class `LiekoMetrics`
+
+Small, fast, console-friendly — perfect for quick debugging and finding slow parts of your code.
+
+Happy profiling!

package/lieko-metrics.js

@@ -0,0 +1,135 @@
+/**
+ * LiekoMetrics - Simple performance metrics tool
+ * Works in Node.js (CommonJS) and browser (global or CDN)
+ * Zero dependencies
+ */
+
+(function(root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    const exports = factory();
+    root.LiekoMetrics = exports.LiekoMetrics;
+    root.liekoPerf = exports.liekoPerf;
+  }
+}(typeof self !== 'undefined' ? self : this, function() {
+
+  /**
+   * Convert duration in ms to human-readable format
+   * @param {number} ms - Duration in milliseconds
+   * @param {number} [precision=2] - Decimal places for µs/ms/s
+   * @returns {string} Formatted duration
+   */
+  function humanDuration(ms, precision = 2) {
+    if (typeof ms !== 'number' || isNaN(ms) || ms < 0) {
+      return "—";
+    }
+
+    if (ms < 1) {
+      return `${(ms * 1000).toFixed(precision)}µs`;
+    }
+    
+    if (ms < 1000) {
+      return `${ms.toFixed(precision)}ms`;
+    }
+    
+    if (ms < 60000) {
+      return `${(ms / 1000).toFixed(precision)}s`;
+    }
+    
+    const minutes = Math.floor(ms / 60000);
+    const seconds = ((ms % 60000) / 1000).toFixed(precision);
+    
+    if (minutes === 0) {
+      return `${seconds}s`;
+    }
+    
+    return `${minutes}m ${seconds}s`;
+  }
+
+  class LiekoMetrics {
+    constructor() {
+      this.markers = new Map();
+      this.metrics = new Map();
+    }
+
+    start(markerName) {
+      if (this.markers.has(markerName)) {
+        console.warn(`Marker "${markerName}" already started. Overwriting previous start time.`);
+      }
+      this.markers.set(markerName, performance.now());
+    }
+
+    stop(markerName) {
+      const endTime = performance.now();
+      const startTime = this.markers.get(markerName);
+
+      if (startTime === undefined) {
+        console.error(`Marker "${markerName}" was not started.`);
+        return null;
+      }
+
+      const duration = endTime - startTime;
+
+      if (!this.metrics.has(markerName)) {
+        this.metrics.set(markerName, []);
+      }
+      this.metrics.get(markerName).push(duration);
+
+      this.markers.delete(markerName);
+
+      console.log(`⏱️  ${markerName} perf: ${humanDuration(duration)}`);
+
+      return duration;
+    }
+
+    getStats(markerName) {
+      const durations = this.metrics.get(markerName) || [];
+      if (durations.length === 0) return null;
+
+      const stats = {
+        count: durations.length,
+        total: durations.reduce((sum, d) => sum + d, 0),
+        average: durations.reduce((sum, d) => sum + d, 0) / durations.length,
+        min: Math.min(...durations),
+        max: Math.max(...durations),
+        latest: durations[durations.length - 1]
+      };
+
+      return stats;
+    }
+
+    printSummary() {
+      console.log('\n📊 Performance Summary:');
+      console.log('='.repeat(50));
+
+      for (const [name, durations] of this.metrics) {
+        const stats = this.getStats(name);
+        if (!stats) continue;
+
+        console.log(`${name}:`);
+        console.log(`  Runs: ${stats.count}`);
+        console.log(`  Avg:   ${humanDuration(stats.average)}`);
+        console.log(`  Min:   ${humanDuration(stats.min)}`);
+        console.log(`  Max:   ${humanDuration(stats.max)}`);
+        console.log(`  Last:  ${humanDuration(stats.latest)}`);
+      }
+    }
+
+    clear() {
+      this.markers.clear();
+      this.metrics.clear();
+      console.log('🧹 Performance metrics cleared');
+    }
+  }
+
+  const liekoPerf = new LiekoMetrics();
+
+  return {
+    LiekoMetrics,
+    liekoPerf
+  };
+
+}));

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "lieko-metrics",
+  "version": "0.0.1",
+  "description": "Super simple performance metrics helper • start/stop markers • nice console logs • avg/min/max stats • human durations (µs/ms/s/m) • zero dependencies",
+  "main": "lieko-metrics.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "files": [
+    "lieko-metrics.js",
+    "README.md"
+  ]
+}