Split code into multiple packages

Author: yamiteru

packages/isitfast/LICENSE renamed to LICENSE

@@ -1,3 +1,117 @@
-# Isitfast monorepo 
+# Isitfast
 
-- [isitfast](./packages/isitfast/README.md)
+A modular benchmarking library with V8 warmup and CPU/RAM denoising for the most accurate and consistent results.
+
+You no longer have to ask yourself, "Is it fast?" Just benchmark it!
+
+## Key Features
+
+- Waits until V8 optimizations kick in and benchmarks become less noisy.
+- Eliminates performance noise caused by benchmark wrapper functions.
+- Reuses a couple of UInt32Arrays to store stats for reduced memory noise.
+- Runs GC before every benchmark and suite for reduced memory noise.
+- Uses high-resolution time in nanoseconds for more accurate CPU results.
+- Exposes lifecycle events for real-time data monitoring.
+- Prints colorful benchmark results in the terminal (verbose/compact).
+- Allows combining different output strategies (terminal/markdown/etc.).
+
+## Installation
+
+To install, run the following command in your terminal:
+
+```shell
+yarn add isitfast
+```
+
+## How to run
+
+It is recommended to run isitfast with the --expose-gc Node flag to enable the library to run GC and collect more statistically correct memory data.
+
+When used in a TypeScript environment, you can run it like this: node --expose-gc -r ts-node/register benchmarks/benchmarkName.ts.
+
+For the most accurate results, it is recommended to run benchmark suites in different JS realms by putting them in separate files and executing them individually.
+
+## Example
+
+```ts
+import { Suite, useTerminal } from "isitfast";
+
+// define your suite with benchmarks
+const testBenchmark = new Suite("Test")
+  .add("emptyAsync", async () => {})
+  .add("emptySync", () => {});
+
+// collect data and print them into a terminal
+useTerminal();
+
+// run all benchmarks and trigger lifecycle events
+testBenchmark.run();
+```
+
+---
+
+# API
+
+## Suite
+
+```ts
+const testTwo = new Suite("Test Two", {
+  // options
+});
+```
+
+These are the default options:
+
+```ts
+{
+  cpu: {
+    chunkSize: 1_000,
+    deviationPercent: 1,
+  },
+  ram: {
+    chunkSize: 5,
+    deviationPercent: 1,
+  },
+  offset: {
+    allow: true,
+    deviationPercent: 1,
+  },
+  gc: {
+    allow: true,
+  }
+}
+```
+
+## Modes
+
+### `useTerminal`
+
+Listens to events and prints verbose suite and benchmark results into a terminal.
+
+```ts
+// subscribe to events
+useTerminal();
+
+// run suite which publishes data to the events
+runBenchmarks.run();
+```
+
+### `useTerminalCompact`
+
+Listens to events and prints compact suite and benchmark results into a terminal.
+
+```ts
+// subscribe to events
+useTerminalCompact();
+
+// run suite which publishes data to the events
+runBenchmarks.run();
+```
+
+## Events
+
+The `Suite` by itself doesn't return any data. For consuming suite and benchmarks data you should listen to events. All events are prefixed with `$`.
+
+Behind the scenes `isitfast` uses [μEve](https://github.com/yamiteru/ueve) to create, subscribe to and publish into events.
+
+You can easily import `sub`/`clr`/`has` event functions from `isitfast`. They're just re-exported functions from `μEve`.

README.md

@@ -1,12 +1,11 @@
 {
   "name": "isitfast",
-  "version": "0.0.0",
-  "private": true,
+  "type": "module",
+  "version": "0.0.8",
   "workspaces": [
     "packages/*"
   ],
   "scripts": {
-    "build": "turbo run build",
     "fix:format": "prettier --write \"**/*.ts\"",
     "fix:lint": "eslint --fix --ext .ts .",
     "fix": "pnpm fix:lint && pnpm fix:format",
@@ -15,6 +14,7 @@
     "check": "pnpm check:lint && pnpm check:format"
   },
   "devDependencies": {
+    "@types/node": "18.15.5",
     "@typescript-eslint/eslint-plugin": "5.56.0",
     "@typescript-eslint/parser": "5.56.0",
     "eslint": "8.37.0",

package.json

@@ -0,0 +1,9 @@
+{
+  "version": "0.0.0",
+  "type": "module",
+  "name": "@isitfast/constants",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "@isitfast/types": "workspace:*"
+  }
+}

packages/constants/package.json

@@ -1,4 +1,3 @@
-import { Either, Fn } from "elfs";
 import {
   Benchmarks,
   Mode,
@@ -9,7 +8,9 @@ import {
   Store,
   Stores,
   Type,
-} from "./types";
+  Fn,
+  Either
+} from "@isitfast/types";
 
 export const STATE: {
   name: string;
@@ -49,7 +50,7 @@ export const OFFSET_MIN: OffsetMin = {
 // Default options used in `preset`
 export const OPTIONS: Options = {
   cpu: {
-    chunkSize: 1_000,
+    chunkSize: 2_000,
     deviationPercent: 1,
   },
   ram: {

packages/isitfast/src/constants.ts renamed to packages/constants/src/index.ts

@@ -0,0 +1,12 @@
+{
+  "version": "0.0.0",
+  "type": "module",
+  "name": "@isitfast/events",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "@isitfast/types": "workspace:*"
+  },
+  "dependencies": {
+    "ueve": "1.4.0"
+  }
+}

packages/events/package.json

@@ -1,5 +1,5 @@
 import { eve } from "ueve/async";
-import { Mode, Offset } from "./types";
+import { Mode, Offset } from "@isitfast/types";
 
 export const $suiteStart = eve<{
   suiteName: string;

packages/isitfast/src/events.ts renamed to packages/events/src/index.ts

@@ -0,0 +1,17 @@
+{
+  "type": "module",
+  "name": "@isitfast/examples",
+  "scripts": {
+    "arrayLoops": "node --loader ts-node/esm src/arrayLoops.ts",
+    "emptyFunctions": "node --loader ts-node/esm src/emptyFunctions.ts"
+  },
+  "dependencies": {
+    "@isitfast/modes": "workspace:*",
+    "@isitfast/suite": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "18.15.5",
+    "ts-node": "10.9.1",
+    "typescript": "next"
+  }
+}

packages/examples/package.json

@@ -1,7 +1,7 @@
-import { useTerminalCompact } from "../src";
-import { Suite } from "../src";
+import { Suite } from "@isitfast/suite";
+import { useTerminalVerbose } from "@isitfast/modes";
 
-const emptyFunctions = new Suite("Array loops")
+const arrayLoops = new Suite("Array loops")
   .setup(() => ({
     result: { _: 0 },
     data: [...new Array(1_000)].map(() => Math.random() * 10),
@@ -27,6 +27,5 @@ const emptyFunctions = new Suite("Array loops")
     data.forEach((v) => (result._ = v));
   });
 
-useTerminalCompact();
 
-emptyFunctions.run();
+useTerminalVerbose(arrayLoops);