@irrelon/emitter 5.0.0 → 5.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/.eslintignore +1 -3
  2. package/.eslintrc.json +35 -18
  3. package/.prettierignore +9 -0
  4. package/.prettierrc.yml +9 -0
  5. package/fixPaths.cjs +183 -0
  6. package/package.json +31 -24
  7. package/readme.md +16 -45
  8. package/src/Emitter.d.ts +190 -0
  9. package/src/Emitter.js +580 -0
  10. package/src/Emitter.ts +294 -247
  11. package/tests/Emitter.test.d.ts +1 -0
  12. package/tests/Emitter.test.js +267 -309
  13. package/tests/Emitter.test.ts +335 -0
  14. package/tsconfig.json +33 -12
  15. package/tsconfig.tsbuildinfo +1 -0
  16. package/.babelrc +0 -11
  17. package/dist/Emitter.d.ts +0 -205
  18. package/dist/Emitter.js +0 -415
package/tests/Emitter.test.d.ts ADDED
@@ -0,0 +1 @@
1
+ export {};
package/tests/Emitter.test.js CHANGED
@@ -1,319 +1,277 @@
1
- const {Emitter, makeEmitter} = require("../dist/Emitter");
2
- const assert = require("assert");
3
-
1
+ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
2
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
3
+ return new (P || (P = Promise))(function (resolve, reject) {
4
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
5
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
6
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
7
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
8
+ });
9
+ };
10
+ import assert from "assert";
11
+ import { Emitter } from "../src/Emitter.js";
4
12
  let expectedAssertions = 0;
5
13
  let actualAssertions = 0;
6
-
7
- function expect (val) {
8
- expectedAssertions = val;
14
+ function expect(val) {
15
+ expectedAssertions = val;
9
16
  }
10
-
11
- function reset () {
12
- expectedAssertions = 0;
13
- actualAssertions = 0;
17
+ function reset() {
18
+ expectedAssertions = 0;
19
+ actualAssertions = 0;
14
20
  }
15
-
16
- function countAssertion () {
17
- actualAssertions++;
21
+ function countAssertion() {
22
+ actualAssertions++;
18
23
  }
19
-
20
- function check () {
21
- if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
22
- return;
23
- }
24
- throw new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
24
+ function check() {
25
+ if (expectedAssertions === undefined || expectedAssertions === actualAssertions) {
26
+ return;
27
+ }
28
+ const err = new Error("expected " + expectedAssertions + " assertions, got " + actualAssertions);
29
+ // @ts-ignore
30
+ this.currentTest.emit("error", err);
25
31
  }
26
-
27
32
  beforeEach(reset);
28
33
  afterEach(check);
29
-
30
34
  describe("Emitter", () => {
31
- describe("new Emitter()", () => {
32
- it("Creates emitter instance by instantiation", () => {
33
- const myClass = new Emitter();
34
-
35
- myClass.on("moo", () => {
36
- });
37
-
38
- assert.strictEqual(myClass._listeners.moo["*"].length, 1, "Listener registered on event");
39
-
40
- myClass.off("moo");
41
-
42
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["*"] || myClass._listeners.moo["*"].length, true, "Listeners all removed from event");
43
- });
44
-
45
- it("Augments an object passed to makeEmitter()", (resolve) => {
46
- const obj = {
47
- "someExistingProp": "hello"
48
- };
49
- makeEmitter(obj);
50
-
51
- function test () {
52
- assert.strictEqual(this.someExistingProp, "hello", "Able to access object props via `this`");
53
- assert.strictEqual(obj._listeners.moo["*"].length, 1, "Listener registered on event");
54
-
55
- resolve();
56
- }
57
-
58
- obj.on("moo", test);
59
-
60
- obj.emit("moo");
61
-
62
- obj.off("moo");
63
-
64
- assert.strictEqual(!obj._listeners.moo || !obj._listeners.moo["*"] || obj._listeners.moo["*"].length, true, "Listeners all removed from event");
65
- });
66
-
67
- it("Supports extending Emitter as a base class", () => {
68
- let testFuncCount = 0;
69
-
70
- // Test extending Emitter and modifying base functionality
71
- class MyClass extends Emitter {
72
- testFunc () {
73
- testFuncCount++;
74
- }
75
-
76
- on (event, id, listener) {
77
- if (typeof id === "function") {
78
- listener = id;
79
- id = "^^noId";
80
- }
81
-
82
- super.on(event, id, listener);
83
- }
84
-
85
- emit (event, ...rest) {
86
- super.emitId(event, "^^noId", ...rest);
87
- }
88
-
89
- off (event, id, func) {
90
- if (typeof id === "function") {
91
- func = id;
92
- id = "^^noId";
93
- } else if (typeof id === "undefined") {
94
- id = "^^noId";
95
- }
96
-
97
- super.off(event, id, func);
98
- }
99
- }
100
-
101
- const myClass = new MyClass();
102
- let emitCount = 0;
103
-
104
- // Register id-based listener
105
- myClass.on("moo", "testId", () => {
106
- emitCount++;
107
- });
108
-
109
- // Register non-id-based listener
110
- myClass.on("moo", () => {
111
- emitCount++;
112
- });
113
-
114
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listener registered on event");
115
-
116
- myClass.emitId("moo", "testId", "foo");
117
-
118
- assert.strictEqual(emitCount, 1, "Event fired correctly");
119
-
120
- myClass.off("moo", "testId");
121
-
122
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["testId"] || myClass._listeners.moo["testId"].length === 0, true, "Listeners all removed from event");
123
- assert.strictEqual(myClass._listeners.moo && myClass._listeners.moo["^^noId"] && myClass._listeners.moo["^^noId"].length === 1, true, "Global listener still there");
124
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["*"] || myClass._listeners.moo["*"].length === 0, true, "Global listener still there");
125
-
126
- myClass.off("moo");
127
-
128
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["*"] || myClass._listeners.moo["*"].length === 0, true, "Listeners all removed from event");
129
- });
130
- });
131
-
132
- describe("off()", () => {
133
- it("Cancels all listeners (event)", () => {
134
- const myClass = new Emitter();
135
- const listener1 = () => {};
136
- const listener2 = () => {};
137
-
138
- myClass.on("moo", () => {});
139
- assert.strictEqual(myClass._listeners.moo["*"].length, 1, "Listeners registered on event");
140
- myClass.on("moo", "testId", () => {});
141
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listeners registered on event");
142
- myClass.on("moo", listener1);
143
- assert.strictEqual(myClass._listeners.moo["*"].length, 2, "Listeners registered on event");
144
- myClass.on("moo", "testId", listener2);
145
- assert.strictEqual(myClass._listeners.moo["testId"].length, 2, "Listeners registered on event");
146
-
147
- myClass.off("moo");
148
-
149
- assert.strictEqual(!myClass._listeners.moo || (myClass._listeners.moo["*"].length === 0 && myClass._listeners.moo["testId"].length === 0), true, "Listeners all removed from event");
150
- });
151
-
152
- it("Cancels id-based listeners (event, id)", () => {
153
- const myClass = new Emitter();
154
- const listener1 = () => {};
155
- const listener2 = () => {};
156
-
157
- myClass.on("moo", () => {});
158
- assert.strictEqual(myClass._listeners.moo["*"].length, 1, "Listeners registered on event");
159
- myClass.on("moo", "testId", () => {});
160
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listeners registered on event");
161
- myClass.on("moo", listener1);
162
- assert.strictEqual(myClass._listeners.moo["*"].length, 2, "Listeners registered on event");
163
- myClass.on("moo", "testId", listener2);
164
- assert.strictEqual(myClass._listeners.moo["testId"].length, 2, "Listeners registered on event");
165
-
166
- myClass.off("moo", "testId");
167
-
168
- assert.strictEqual(myClass._listeners.moo["*"].length === 2, true, "Listeners all removed from event");
169
- assert.strictEqual(!myClass._listeners.moo["testId"] || myClass._listeners.moo["testId"].length === 0, true, "Listeners all removed from event");
170
- });
171
-
172
- it("Cancels listener-based listeners (event, listener)", () => {
173
- const myClass = new Emitter();
174
- const listener1 = () => {};
175
- const listener2 = () => {};
176
-
177
- myClass.on("moo", () => {});
178
- assert.strictEqual(myClass._listeners.moo["*"].length, 1, "Listeners registered on event");
179
- myClass.on("moo", "testId", () => {});
180
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listeners registered on event");
181
- myClass.on("moo", listener1);
182
- assert.strictEqual(myClass._listeners.moo["*"].length, 2, "Listeners registered on event");
183
- myClass.on("moo", "testId", listener2);
184
- assert.strictEqual(myClass._listeners.moo["testId"].length, 2, "Listeners registered on event");
185
-
186
- myClass.off("moo", listener1);
187
-
188
- assert.strictEqual(myClass._listeners.moo["*"].length === 1, true, "Listeners all removed from event");
189
- assert.strictEqual(myClass._listeners.moo["testId"].length === 2, true, "Listeners all removed from event");
190
- });
191
-
192
- it("Cancels id-based + listener-based listeners (event, id, listener)", () => {
193
- const myClass = new Emitter();
194
- const listener1 = () => {};
195
- const listener2 = () => {};
196
-
197
- myClass.on("moo", () => {});
198
- assert.strictEqual(myClass._listeners.moo["*"].length, 1, "Listeners registered on event");
199
- myClass.on("moo", "testId", () => {});
200
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listeners registered on event");
201
- myClass.on("moo", listener1);
202
- assert.strictEqual(myClass._listeners.moo["*"].length, 2, "Listeners registered on event");
203
- myClass.on("moo", "testId", listener2);
204
- assert.strictEqual(myClass._listeners.moo["testId"].length, 2, "Listeners registered on event");
205
-
206
- myClass.off("moo", "testId", listener2);
207
-
208
- assert.strictEqual(myClass._listeners.moo["*"].length === 2, true, "Listeners all removed from event");
209
- assert.strictEqual(myClass._listeners.moo["testId"].length === 1, true, "Listeners all removed from event");
210
- });
211
- });
212
-
213
- describe("emitStatic()", () => {
214
- it("Static emitter will emit when a new listener is added", (resolve) => {
215
- const MyClass = function () {};
216
-
217
- expect(1);
218
-
219
- makeEmitter(MyClass.prototype);
220
-
221
- const myClass = new MyClass();
222
- myClass.emitStatic("moo");
223
- myClass.on("moo", () => {
224
- countAssertion();
225
- assert.ok(true, "Callback was fired");
226
- resolve();
227
- });
228
- });
229
- });
230
-
231
- describe("cancelStatic()", () => {
232
- it("Removes static emitter", (resolve) => {
233
- const MyClass = function () {
234
- };
235
-
236
- expect(1);
237
-
238
- makeEmitter(MyClass.prototype);
239
-
240
- const myClass = new MyClass();
241
- myClass.emitStatic("moo");
242
- myClass.on("moo", () => {
243
- countAssertion();
244
- assert.ok(true, "Callback was fired");
245
- });
246
-
247
- myClass.cancelStatic("moo");
248
- myClass.on("moo", () => {
249
- countAssertion();
250
- assert.ok(false, "Callback was fired");
251
- });
252
-
253
- setTimeout(() => {
254
- resolve();
255
- }, 10);
256
- });
257
- });
258
-
259
- describe("one()", () => {
260
- it("Only fires the last listener added, cancelling all other listeners before it", (resolve) => {
261
- const MyClass = function () {
262
- };
263
- expect(1);
264
-
265
- makeEmitter(MyClass.prototype);
266
-
267
- const myClass = new MyClass();
268
- myClass.on("moo", () => {
269
- countAssertion();
270
- assert.ok(false, "Correct callback was fired");
271
- });
272
- myClass.on("moo", () => {
273
- countAssertion();
274
- assert.ok(false, "Correct callback was fired");
275
- });
276
- myClass.one("moo", () => {
277
- countAssertion();
278
- assert.ok(true, "Correct callback was fired");
279
- });
280
- myClass.emit("moo");
281
-
282
- setTimeout(() => {
283
- resolve();
284
- }, 10);
285
- });
286
- });
287
-
288
- describe("emitId()", () => {
289
- it("Fires an id-based event first followed by a global event", () => {
290
- const myClass = new Emitter();
291
- let emitCount = 0;
292
-
293
- // Register id-based listener
294
- myClass.on("moo", "testId", () => {
295
- emitCount++;
296
- });
297
-
298
- // Register non-id-based listener
299
- myClass.on("moo", () => {
300
- emitCount++;
301
- });
302
-
303
- assert.strictEqual(myClass._listeners.moo["testId"].length, 1, "Listener registered on event");
304
-
305
- myClass.emitId("moo", "testId", "foo");
306
-
307
- assert.strictEqual(emitCount, 2, "Event fired correctly");
308
-
309
- myClass.off("moo", "testId");
310
-
311
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["testId"] || myClass._listeners.moo["testId"].length, true, "Listeners all removed from event");
312
- assert.strictEqual(myClass._listeners.moo && myClass._listeners.moo["*"] && myClass._listeners.moo["*"].length === 1, true, "Global listener still there");
313
-
314
- myClass.off("moo");
315
-
316
- assert.strictEqual(!myClass._listeners.moo || !myClass._listeners.moo["*"] || myClass._listeners.moo["*"].length === 0, true, "Listeners all removed from event");
317
- });
318
- });
35
+ describe("new Emitter()", () => {
36
+ it("Creates emitter instance by instantiation", () => {
37
+ var _a, _b;
38
+ const myClass = new Emitter();
39
+ myClass.on("moo", () => {
40
+ });
41
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listener registered on event");
42
+ myClass.off("moo");
43
+ assert.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) || !myClass._eventListeners.moo["*"] || myClass._eventListeners.moo["*"].length, true, "Listeners all removed from event");
44
+ });
45
+ it("Supports extending Emitter as a base class", () => {
46
+ var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
47
+ let testFuncCount = 0;
48
+ // Test extending Emitter and modifying base functionality
49
+ class MyClass extends Emitter {
50
+ testFunc() {
51
+ testFuncCount++;
52
+ }
53
+ on(eventName, ...rest) {
54
+ const restTypes = rest.map((arg) => typeof arg);
55
+ if (restTypes[0] === "function") {
56
+ const listener = restTypes[0];
57
+ const id = "^^noId";
58
+ return super.on(eventName, id, listener);
59
+ }
60
+ return super.on(eventName, rest[0], rest[1]);
61
+ }
62
+ // @ts-ignore
63
+ emit(eventName, ...rest) {
64
+ return super.emitId(eventName, "^^noId", ...rest);
65
+ }
66
+ off(eventName, ...rest) {
67
+ let id = rest[0];
68
+ let func = rest[1];
69
+ if (typeof rest[0] === "function") {
70
+ func = rest[0];
71
+ id = "^^noId";
72
+ }
73
+ else if (typeof id === "undefined") {
74
+ id = "^^noId";
75
+ }
76
+ return super.off(eventName, id, func);
77
+ }
78
+ }
79
+ const myClass = new MyClass();
80
+ let emitCount = 0;
81
+ // Register id-based listener
82
+ myClass.on("moo", "testId", () => {
83
+ emitCount++;
84
+ });
85
+ // Register non-id-based listener
86
+ myClass.on("moo", () => {
87
+ emitCount++;
88
+ });
89
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["testId"].length, 1, "Listener registered on event");
90
+ myClass.emitId("moo", "testId", "foo");
91
+ assert.strictEqual(emitCount, 1, "Event fired correctly");
92
+ myClass.off("moo", "testId");
93
+ assert.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) || !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) || ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length) === 0, true, "Listeners all removed from event");
94
+ assert.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) && ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["^^noId"]) && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["^^noId"].length) === 1, true, "Global listener still there");
95
+ assert.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) || !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) || ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Global listener still there");
96
+ myClass.off("moo");
97
+ assert.strictEqual(!((_l = myClass._eventListeners) === null || _l === void 0 ? void 0 : _l.moo) || !((_m = myClass._eventListeners) === null || _m === void 0 ? void 0 : _m.moo["*"]) || ((_o = myClass._eventListeners) === null || _o === void 0 ? void 0 : _o.moo["*"].length) === 0, true, "Listeners all removed from event");
98
+ });
99
+ });
100
+ describe("emit()", () => {
101
+ it("Supports awaiting async listeners", () => __awaiter(void 0, void 0, void 0, function* () {
102
+ const emitter = new Emitter();
103
+ let listenerFiredCount = 0;
104
+ emitter.on("foo", () => __awaiter(void 0, void 0, void 0, function* () {
105
+ return new Promise((resolve) => {
106
+ setTimeout(() => {
107
+ listenerFiredCount++;
108
+ resolve();
109
+ }, 1000);
110
+ });
111
+ }));
112
+ emitter.on("foo", () => __awaiter(void 0, void 0, void 0, function* () {
113
+ return new Promise((resolve) => {
114
+ setTimeout(() => {
115
+ listenerFiredCount++;
116
+ resolve();
117
+ }, 1000);
118
+ });
119
+ }));
120
+ const time = new Date().getTime();
121
+ yield emitter.emit("foo");
122
+ const delta = new Date().getTime() - time;
123
+ assert.ok(delta > 900, "Delta was not correct, await may not have paused?");
124
+ }));
125
+ });
126
+ describe("off()", () => {
127
+ it("Cancels all listeners (event)", () => {
128
+ var _a, _b, _c, _d, _e, _f, _g;
129
+ const myClass = new Emitter();
130
+ const listener1 = () => { };
131
+ const listener2 = () => { };
132
+ myClass.on("moo", () => { });
133
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
134
+ myClass.on("moo", "testId", () => { });
135
+ assert.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
136
+ myClass.on("moo", listener1);
137
+ assert.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
138
+ myClass.on("moo", "testId", listener2);
139
+ assert.strictEqual((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length, 2, "Listeners registered on event");
140
+ myClass.off("moo");
141
+ assert.strictEqual(!((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) || (((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"].length) === 0 && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["testId"].length) === 0), true, "Listeners all removed from event");
142
+ });
143
+ it("Cancels id-based listeners (event, id)", () => {
144
+ var _a, _b, _c, _d, _e, _f, _g;
145
+ const myClass = new Emitter();
146
+ const listener1 = () => { };
147
+ const listener2 = () => { };
148
+ myClass.on("moo", () => { });
149
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
150
+ myClass.on("moo", "testId", () => { });
151
+ assert.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
152
+ myClass.on("moo", listener1);
153
+ assert.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
154
+ myClass.on("moo", "testId", listener2);
155
+ assert.strictEqual((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length, 2, "Listeners registered on event");
156
+ myClass.off("moo", "testId");
157
+ assert.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo["*"].length) === 2, true, "Listeners all removed from event");
158
+ assert.strictEqual(!((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["testId"]) || ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["testId"].length) === 0, true, "Listeners all removed from event");
159
+ });
160
+ it("Cancels listener-based listeners (event, listener)", () => {
161
+ var _a, _b, _c, _d, _e, _f;
162
+ const myClass = new Emitter();
163
+ const listener1 = () => { };
164
+ const listener2 = () => { };
165
+ myClass.on("moo", () => { });
166
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
167
+ myClass.on("moo", "testId", () => { });
168
+ assert.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
169
+ myClass.on("moo", listener1);
170
+ assert.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
171
+ myClass.on("moo", "testId", listener2);
172
+ assert.strictEqual((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length, 2, "Listeners registered on event");
173
+ myClass.off("moo", listener1);
174
+ assert.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo["*"].length) === 1, true, "Listeners all removed from event");
175
+ assert.strictEqual(((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["testId"].length) === 2, true, "Listeners all removed from event");
176
+ });
177
+ it("Cancels id-based + listener-based listeners (event, id, listener)", () => {
178
+ var _a, _b, _c, _d, _e, _f;
179
+ const myClass = new Emitter();
180
+ const listener1 = () => { };
181
+ const listener2 = () => { };
182
+ myClass.on("moo", () => { });
183
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["*"].length, 1, "Listeners registered on event");
184
+ myClass.on("moo", "testId", () => { });
185
+ assert.strictEqual((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo["testId"].length, 1, "Listeners registered on event");
186
+ myClass.on("moo", listener1);
187
+ assert.strictEqual((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["*"].length, 2, "Listeners registered on event");
188
+ myClass.on("moo", "testId", listener2);
189
+ assert.strictEqual((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length, 2, "Listeners registered on event");
190
+ myClass.off("moo", "testId", listener2);
191
+ assert.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo["*"].length) === 2, true, "Listeners all removed from event");
192
+ assert.strictEqual(((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["testId"].length) === 1, true, "Listeners all removed from event");
193
+ });
194
+ });
195
+ describe("emitStatic()", () => {
196
+ it("Static emitter will emit when a new listener is added", (resolve) => {
197
+ class MyClass extends Emitter {
198
+ }
199
+ expect(1);
200
+ const myClass = new MyClass();
201
+ myClass.emitStatic("moo");
202
+ myClass.on("moo", () => {
203
+ countAssertion();
204
+ assert.ok(true, "Callback was fired");
205
+ resolve();
206
+ });
207
+ });
208
+ });
209
+ describe("cancelStatic()", () => {
210
+ it("Removes static emitter", (resolve) => {
211
+ class MyClass extends Emitter {
212
+ }
213
+ expect(1);
214
+ const myClass = new MyClass();
215
+ myClass.emitStatic("moo");
216
+ myClass.on("moo", () => {
217
+ countAssertion();
218
+ assert.ok(true, "Callback was fired");
219
+ });
220
+ myClass.cancelStatic("moo");
221
+ myClass.on("moo", () => {
222
+ countAssertion();
223
+ assert.ok(false, "Callback was fired");
224
+ });
225
+ setTimeout(() => {
226
+ resolve();
227
+ }, 10);
228
+ });
229
+ });
230
+ describe("overwrite()", () => {
231
+ it("Only fires the last listener added, cancelling all other listeners before it", (resolve) => {
232
+ class MyClass extends Emitter {
233
+ }
234
+ expect(1);
235
+ const myClass = new MyClass();
236
+ myClass.on("moo", () => {
237
+ countAssertion();
238
+ assert.ok(false, "Correct callback was fired");
239
+ });
240
+ myClass.on("moo", () => {
241
+ countAssertion();
242
+ assert.ok(false, "Correct callback was fired");
243
+ });
244
+ myClass.overwrite("moo", () => {
245
+ countAssertion();
246
+ assert.ok(true, "Correct callback was fired");
247
+ });
248
+ myClass.emit("moo");
249
+ setTimeout(() => {
250
+ resolve();
251
+ }, 10);
252
+ });
253
+ });
254
+ describe("emitId()", () => {
255
+ it("Fires an id-based event first followed by a global event", () => {
256
+ var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
257
+ const myClass = new Emitter();
258
+ let emitCount = 0;
259
+ // Register id-based listener
260
+ myClass.on("moo", "testId", () => {
261
+ emitCount++;
262
+ });
263
+ // Register non-id-based listener
264
+ myClass.on("moo", () => {
265
+ emitCount++;
266
+ });
267
+ assert.strictEqual((_a = myClass._eventListeners) === null || _a === void 0 ? void 0 : _a.moo["testId"].length, 1, "Listener registered on event");
268
+ myClass.emitId("moo", "testId", "foo");
269
+ assert.strictEqual(emitCount, 2, "Event fired correctly");
270
+ myClass.off("moo", "testId");
271
+ assert.strictEqual(!((_b = myClass._eventListeners) === null || _b === void 0 ? void 0 : _b.moo) || !((_c = myClass._eventListeners) === null || _c === void 0 ? void 0 : _c.moo["testId"]) || ((_d = myClass._eventListeners) === null || _d === void 0 ? void 0 : _d.moo["testId"].length), true, "Listeners all removed from event");
272
+ assert.strictEqual(((_e = myClass._eventListeners) === null || _e === void 0 ? void 0 : _e.moo) && ((_f = myClass._eventListeners) === null || _f === void 0 ? void 0 : _f.moo["*"]) && ((_g = myClass._eventListeners) === null || _g === void 0 ? void 0 : _g.moo["*"].length) === 1, true, "Global listener still there");
273
+ myClass.off("moo");
274
+ assert.strictEqual(!((_h = myClass._eventListeners) === null || _h === void 0 ? void 0 : _h.moo) || !((_j = myClass._eventListeners) === null || _j === void 0 ? void 0 : _j.moo["*"]) || ((_k = myClass._eventListeners) === null || _k === void 0 ? void 0 : _k.moo["*"].length) === 0, true, "Listeners all removed from event");
275
+ });
276
+ });
319
277
  });