feat: move registry and runtime into separate packages

packages/utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodes/utils",
-  "version": "1.0.0",
+  "version": "0.0.1",
   "description": "",
   "main": "src/index.ts",
   "scripts": {

packages/utils/src/index.ts

@@ -2,3 +2,5 @@ export * from "./wasm-wrapper";
 export * from "./flatTree"
 export * from "./encoding"
 export * from "./fastHash"
+export * from "./logger"
+export * from "./performance"

packages/utils/src/logger.ts

@@ -0,0 +1,29 @@
+export const createLogger = (() => {
+  let maxLength = 5;
+  return (scope: string) => {
+    maxLength = Math.max(maxLength, scope.length);
+    let muted = false;
+
+    let isGrouped = false;
+
+    function s(color: string, ...args: any) {
+      return isGrouped ? [...args] : [`[%c${scope.padEnd(maxLength, " ")}]:`, `color: ${color}`, ...args];
+    }
+
+    return {
+      log: (...args: any[]) => !muted && console.log(...s("#888", ...args)),
+      info: (...args: any[]) => !muted && console.info(...s("#888", ...args)),
+      warn: (...args: any[]) => !muted && console.warn(...s("#888", ...args)),
+      error: (...args: any[]) => console.error(...s("#f88", ...args)),
+      group: (...args: any[]) => { if (!muted) { console.groupCollapsed(...s("#888", ...args)); isGrouped = true; } },
+      groupEnd: () => { if (!muted) { console.groupEnd(); isGrouped = false } },
+      mute() {
+        muted = true;
+      },
+      unmute() {
+        muted = false;
+      }
+
+    }
+  }
+})();

packages/utils/src/performance.ts

@@ -0,0 +1,103 @@
+export type PerformanceData = Record<string, number[]>[];
+
+export interface PerformanceStore {
+  startRun(): void;
+  stopRun(): void;
+  addPoint(name: string, value?: number): void;
+  endPoint(name?: string): void;
+  mergeData(data: PerformanceData[number]): void;
+  get: () => PerformanceData;
+  subscribe: (cb: (v: PerformanceData) => void) => () => void;
+}
+
+export function createPerformanceStore(): PerformanceStore {
+
+  let data: PerformanceData = [];
+
+  let currentRun: Record<string, number[]> | undefined;
+  let temp: Record<string, number> | undefined;
+  let lastPoint: string | undefined;
+
+  const listeners: ((v: PerformanceData) => void)[] = [];
+  function subscribe(cb: (v: PerformanceData) => void) {
+    listeners.push(cb);
+    return () => {
+      const i = listeners.indexOf(cb);
+      if (i > -1) listeners.splice(i, 1);
+    }
+  }
+
+  function set(v: PerformanceData) {
+    listeners.forEach((l) => l(v));
+  }
+
+  function startRun() {
+    if (currentRun) return;
+    currentRun = {};
+    lastPoint = undefined;
+    temp = {
+      start: performance.now()
+    }
+  }
+
+  function stopRun() {
+    if (currentRun && temp) {
+      currentRun["total"] = [performance.now() - temp.start];
+      data.push(currentRun);
+      data = data.slice(-100);
+      currentRun = undefined;
+      temp = undefined;
+      if (set) set(data);
+    }
+  }
+
+  function addPoint(name: string, value?: number) {
+    if (!currentRun) return;
+    if (value === undefined) {
+      if (temp) {
+        lastPoint = name;
+        temp[name] = performance.now();
+      }
+    } else {
+      currentRun[name] = currentRun[name] || [];
+      currentRun[name].push(value);
+    }
+  }
+
+  function get() {
+    return data;
+  }
+
+  function mergeData(newData: PerformanceData[number]) {
+
+    let r = currentRun;
+    if (!r) return;
+
+    Object.keys(newData).forEach((name) => {
+      if (name in r) {
+        r[name].push(...newData[name]);
+      } else {
+        r[name] = newData[name];
+      }
+    });
+  }
+
+  function endPoint(name = lastPoint) {
+    if (name === lastPoint) lastPoint = undefined;
+    if (name && currentRun && temp && name in temp) {
+      currentRun[name] = currentRun[name] || [];
+      currentRun[name].push(performance.now() - temp[name]);
+      delete temp[name];
+    }
+  }
+
+  return {
+    subscribe,
+    startRun,
+    stopRun,
+    addPoint,
+    endPoint,
+    mergeData,
+    get
+  }
+}