chore: extract event-emitter from core

Signed-off-by: Jari Kolehmainen <jari.kolehmainen@gmail.com>

packages/utility-features/event-emitter/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: "@k8slens/eslint-config/eslint",
+  parserOptions: {
+    project: "./tsconfig.json",
+  },
+};

packages/utility-features/event-emitter/.prettierrc

@@ -0,0 +1 @@
+"@k8slens/eslint-config/prettier"

packages/utility-features/event-emitter/index.ts

@@ -0,0 +1 @@
+export * from "./src/event-emitter";

packages/utility-features/event-emitter/jest.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/jest").monorepoPackageConfig(__dirname).configForReact;

packages/utility-features/event-emitter/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@k8slens/event-emitter",
+  "private": false,
+  "version": "1.0.0-alpha.1",
+  "description": "Event emitter",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": {
+    "name": "OpenLens Authors",
+    "email": "info@k8slens.dev"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/lensapp/lens",
+  "scripts": {
+    "build": "webpack",
+    "clean": "rimraf dist/",
+    "dev": "webpack --mode=development --watch",
+    "test": "jest --coverage --runInBand",
+    "lint": "lens-lint",
+    "lint:fix": "lens-lint --fix"
+  },
+  "peerDependencies": {
+  },
+  "devDependencies": {
+    "@k8slens/eslint-config": "^6.5.0-alpha.2",
+    "@k8slens/jest": "^6.5.0-alpha.4",
+    "@k8slens/typescript": "^6.5.0-alpha.2"
+  }
+}

packages/utility-features/event-emitter/src/event-emitter.test.ts

@@ -0,0 +1,115 @@
+import { EventEmitter } from "./event-emitter";
+
+describe("EventEmitter", () => {
+  it("should stop early if a listener returns false", () => {
+    let called = false;
+    const e = new EventEmitter<[]>();
+
+    e.addListener(() => false, {});
+    e.addListener(() => {
+      called = true;
+    }, {});
+    e.emit();
+
+    expect(called).toBe(false);
+  });
+
+  it("shouldn't stop early if a listener returns 0", () => {
+    let called = false;
+    const e = new EventEmitter<[]>();
+
+    e.addListener(() => 0 as never, {});
+    e.addListener(() => {
+      called = true;
+    }, {});
+    e.emit();
+
+    expect(called).toBe(true);
+  });
+
+  it("prepended listeners should be called before others", () => {
+    const callOrder: number[] = [];
+    const e = new EventEmitter<[]>();
+
+    e.addListener(() => {
+      callOrder.push(1);
+    }, {});
+    e.addListener(() => {
+      callOrder.push(2);
+    }, {});
+    e.addListener(
+      () => {
+        callOrder.push(3);
+      },
+      { prepend: true },
+    );
+    e.emit();
+
+    expect(callOrder).toStrictEqual([3, 1, 2]);
+  });
+
+  it("once listeners should be called only once", () => {
+    const callOrder: number[] = [];
+    const e = new EventEmitter<[]>();
+
+    e.addListener(() => {
+      callOrder.push(1);
+    }, {});
+    e.addListener(() => {
+      callOrder.push(2);
+    }, {});
+    e.addListener(
+      () => {
+        callOrder.push(3);
+      },
+      { once: true },
+    );
+    e.emit();
+    e.emit();
+
+    expect(callOrder).toStrictEqual([1, 2, 3, 1, 2]);
+  });
+
+  it("removeListener should stop the listener from being called", () => {
+    const callOrder: number[] = [];
+    const e = new EventEmitter<[]>();
+    const r = () => {
+      callOrder.push(3);
+    };
+
+    e.addListener(() => {
+      callOrder.push(1);
+    }, {});
+    e.addListener(() => {
+      callOrder.push(2);
+    }, {});
+    e.addListener(r);
+
+    e.emit();
+    e.removeListener(r);
+    e.emit();
+
+    expect(callOrder).toStrictEqual([1, 2, 3, 1, 2]);
+  });
+
+  it("removeAllListeners should stop the all listeners from being called", () => {
+    const callOrder: number[] = [];
+    const e = new EventEmitter<[]>();
+
+    e.addListener(() => {
+      callOrder.push(1);
+    });
+    e.addListener(() => {
+      callOrder.push(2);
+    });
+    e.addListener(() => {
+      callOrder.push(3);
+    });
+
+    e.emit();
+    e.removeAllListeners();
+    e.emit();
+
+    expect(callOrder).toStrictEqual([1, 2, 3]);
+  });
+});

packages/utility-features/event-emitter/src/event-emitter.ts

@@ -0,0 +1,36 @@
+export interface EventEmitterOptions {
+  once?: boolean; // call once and remove
+  prepend?: boolean; // put listener to the beginning
+}
+
+export type EventEmitterCallback<D extends any[]> = (...data: D) => void | boolean;
+
+export class EventEmitter<D extends any[]> {
+  protected listeners: [EventEmitterCallback<D>, EventEmitterOptions][] = [];
+
+  addListener(callback: EventEmitterCallback<D>, options: EventEmitterOptions = {}) {
+    const fn = options.prepend ? "unshift" : "push";
+
+    this.listeners[fn]([callback, options]);
+  }
+
+  removeListener(callback: EventEmitterCallback<D>) {
+    this.listeners = this.listeners.filter(([cb]) => cb !== callback);
+  }
+
+  removeAllListeners() {
+    this.listeners.length = 0;
+  }
+
+  emit(...data: D) {
+    for (const [callback, { once }] of this.listeners) {
+      if (once) {
+        this.removeListener(callback);
+      }
+
+      if (callback(...data) === false) {
+        break;
+      }
+    }
+  }
+}

packages/utility-features/event-emitter/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "@k8slens/typescript/config/base.json",
+  "include": ["**/*.ts"]
+}

packages/utility-features/event-emitter/webpack.config.js

@@ -0,0 +1 @@
+module.exports = require("@k8slens/webpack").configForNode;