websocket-ts 1.1.0 → 2.1.1

package/src/websocketBuilder.ts

@@ -1,98 +0,0 @@
-import {Backoff} from "./backoff/backoff";
-import {Buffer} from "./buffer/buffer";
-import {RetryEventDetails, Websocket, WebsocketEvents} from "./websocket";
-
-/**
- * Used to build Websocket-instances.
- */
-export class WebsocketBuilder {
-    private readonly url: string;
-    private ws: Websocket | null = null;
-    private protocols?: string | string[];
-    private backoff?: Backoff;
-    private buffer?: Buffer<string | ArrayBufferLike | Blob | ArrayBufferView>;
-    private onOpenListeners: ({
-        listener: (instance: Websocket, ev: Event) => any,
-        options?: boolean | EventListenerOptions
-    })[] = [];
-    private onCloseListeners: ({
-        listener: (instance: Websocket, ev: CloseEvent) => any,
-        options?: boolean | EventListenerOptions
-    })[] = [];
-    private onErrorListeners: ({
-        listener: (instance: Websocket, ev: Event) => any,
-        options?: boolean | EventListenerOptions
-    })[] = [];
-    private onMessageListeners: ({
-        listener: (instance: Websocket, ev: MessageEvent) => any,
-        options?: boolean | EventListenerOptions
-    })[] = [];
-    private onRetryListeners: ({
-        listener: (instance: Websocket, ev: CustomEvent<RetryEventDetails>) => any,
-        options?: boolean | EventListenerOptions
-    })[] = [];
-
-    constructor(url: string) {
-        this.url = url;
-    }
-
-    public withProtocols(p: string | string[]): WebsocketBuilder {
-        this.protocols = p;
-        return this;
-    }
-
-    public withBackoff(backoff: Backoff): WebsocketBuilder {
-        this.backoff = backoff;
-        return this;
-    }
-
-    public withBuffer(buffer: Buffer<any>): WebsocketBuilder {
-        this.buffer = buffer;
-        return this;
-    }
-
-    public onOpen(listener: (instance: Websocket, ev: Event) => any,
-                  options?: boolean | EventListenerOptions): WebsocketBuilder {
-        this.onOpenListeners.push({listener, options});
-        return this;
-    }
-
-    public onClose(listener: (instance: Websocket, ev: CloseEvent) => any,
-                   options?: boolean | EventListenerOptions): WebsocketBuilder {
-        this.onCloseListeners.push({listener, options});
-        return this;
-    }
-
-    public onError(listener: (instance: Websocket, ev: Event) => any,
-                   options?: boolean | EventListenerOptions): WebsocketBuilder {
-        this.onErrorListeners.push({listener, options});
-        return this;
-    }
-
-    public onMessage(listener: (instance: Websocket, ev: MessageEvent) => any,
-                     options?: boolean | EventListenerOptions): WebsocketBuilder {
-        this.onMessageListeners.push({listener, options});
-        return this;
-    }
-
-    public onRetry(listener: (instance: Websocket, ev: CustomEvent<RetryEventDetails>) => any,
-                   options?: boolean | EventListenerOptions): WebsocketBuilder {
-        this.onRetryListeners.push({listener, options});
-        return this;
-    }
-
-    /**
-     * Multiple calls to build() will always return the same websocket-instance.
-     */
-    public build(): Websocket {
-        if (this.ws !== null)
-            return this.ws;
-        this.ws = new Websocket(this.url, this.protocols, this.buffer, this.backoff);
-        this.onOpenListeners.forEach(h => this.ws?.addEventListener(WebsocketEvents.open, h.listener, h.options));
-        this.onCloseListeners.forEach(h => this.ws?.addEventListener(WebsocketEvents.close, h.listener, h.options));
-        this.onErrorListeners.forEach(h => this.ws?.addEventListener(WebsocketEvents.error, h.listener, h.options));
-        this.onMessageListeners.forEach(h => this.ws?.addEventListener(WebsocketEvents.message, h.listener, h.options));
-        this.onRetryListeners.forEach(h => this.ws?.addEventListener(WebsocketEvents.retry, h.listener, h.options));
-        return this.ws;
-    }
-}

package/test/backoff/constantbackoff.test.ts

@@ -1,21 +0,0 @@
-import {ConstantBackoff} from "../../src";
-
-describe("Testsuite for ConstantBackoff", () => {
-    test("ConstantBackoff should always return the same value 0", () => {
-        const sut = new ConstantBackoff(0);
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(0);
-        sut.reset();
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(0);
-    });
-
-    test("ConstantBackoff should always return the same value 1000", () => {
-        const sut = new ConstantBackoff(1000);
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(1000);
-        sut.reset();
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(1000);
-    });
-})

package/test/backoff/exponentialbackoff.test.ts

@@ -1,13 +0,0 @@
-import {ExponentialBackoff} from "../../src/";
-
-describe("Testsuite for ExponentialBackoff", () => {
-    test("ExponentialBackoff should produce an exponentially increasing series", () => {
-        const sut = new ExponentialBackoff(100, 7);
-        const expected = [100, 200, 400, 800, 1600, 3200, 6400, 6400, 6400, 6400];
-        for (let i = 0; i < expected.length; i++)
-            expect(sut.next()).toBe(expected[i]);
-        sut.reset()
-        for (let i = 0; i < expected.length; i++)
-            expect(sut.next()).toBe(expected[i]);
-    });
-});

package/test/backoff/linearbackoff.test.ts

@@ -1,32 +0,0 @@
-import {LinearBackoff} from "../../src";
-
-describe("Testsuite for LinearBackoff", () => {
-    test("LinearBackoff should produce a linearly increasing series starting with 0", () => {
-        const sut = new LinearBackoff(0, 2000, 8000);
-        const expected = [0, 2000, 4000, 6000, 8000, 8000, 8000, 8000, 8000, 8000];
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(expected[i]);
-        sut.reset();
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(expected[i]);
-    });
-
-    test("LinearBackoff should produce a linearly increasing series starting with 1000", () => {
-        const sut = new LinearBackoff(1000, 3000, 10000);
-        const expected = [1000, 4000, 7000, 10000, 10000, 10000, 10000, 10000, 10000, 10000];
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(expected[i]);
-        sut.reset();
-        for (let i = 0; i < 10; i++)
-            expect(sut.next()).toBe(expected[i]);
-    });
-
-    test("LinearBackoff with undefined maximum should increase without bounds", () => {
-        const sut = new LinearBackoff(1000, 1000);
-        for (let i = 0; i < 100; i++)
-            expect(sut.next()).toBe(1000 + 1000 * i);
-        sut.reset();
-        for (let i = 0; i < 100; i++)
-            expect(sut.next()).toBe(1000 + 1000 * i);
-    })
-})

package/test/buffer/common.ts

@@ -1,10 +0,0 @@
-export const createEmptyArray = (len: number): Array<number> => {
-    return new Array<number>(len);
-}
-
-export const createSequentialArray = (len: number): Array<number> => {
-    const arr = new Array<number>(len);
-    for (let i = 0; i < arr.length; i++)
-        arr[i] = i;
-    return arr;
-}

package/test/buffer/lrubuffer.test.ts

@@ -1,128 +0,0 @@
-import {LRUBuffer} from "../../src";
-
-describe("Testsuite for LRUBuffer", () => {
-    const capacity = 5;
-
-    test("LRUBuffer should return correct capacity", () => {
-        const sut = new LRUBuffer<number>(capacity);
-        expect(sut.cap()).toBe(capacity);
-    })
-
-    test("LRUBuffer should return correct length", () => {
-        const sut = new LRUBuffer<number>(capacity);
-        expect(sut.len()).toBe(0);
-        for (let i = 0; i <= 2 * capacity; i++) {
-            expect(sut.write([i])).toBe(1);
-            expect(sut.len()).toBe(i >= capacity ? capacity : i + 1);
-        }
-    });
-
-    test("LRUBuffer read/write zero elements", () => {
-        const sut1 = new LRUBuffer<number>(capacity);
-        const writeArr1 = createSequentialArray(0);
-        const readArr1 = createEmptyArray(0);
-        expect(sut1.write(writeArr1)).toBe(writeArr1.length);
-        expect(sut1.len()).toBe(writeArr1.length);
-        expect(sut1.read(readArr1)).toBe(writeArr1.length);
-        expect(readArr1).toEqual(writeArr1);
-    });
-
-    test("LRUBuffer read/write single elements", () => {
-        const sut = new LRUBuffer<number>(capacity)
-        const expected = [] as number[];
-        for (let i = 0; i < capacity * 3 + 2; i++) {
-            // write new element to buffer
-            expect(sut.write([i])).toBe(1);
-            expected.push(i);
-
-            // drop the last written element from expected if we exceed capacity
-            if (i > capacity - 1)
-                expected.shift();
-
-            // read actual elements
-            const r = createEmptyArray(i);
-            expect(sut.read(r)).toBe(i > capacity ? capacity : i);
-            for (let j = 0; j < i; j++) {
-                if (j > capacity - 1)
-                    expect(r[j]).toBeUndefined();
-                else
-                    expect(r[j]).toBe(expected[j]);
-            }
-        }
-    });
-
-    test("LRUBuffer read/write multiple elements", () => {
-        for (let i = 0; i < 2 * capacity; i++) {
-            const sut = new LRUBuffer<number>(capacity);
-            const writeArr = createSequentialArray(i);
-            const readArr = createEmptyArray(i);
-            expect(sut.write(writeArr)).toBe(i);
-            expect(sut.read(readArr)).toBe(i > capacity ? capacity : i);
-            for (let j = 0; j < i; j++) {
-                if (j > capacity - 1)
-                    expect(readArr[j]).toBeUndefined();
-                else
-                    expect(readArr[j]).toBe(writeArr[i > capacity ? j - (capacity - i) : j]);
-            }
-        }
-    });
-
-    test("LRUBuffer read/write on buffer with zero capacity should always return zero", () => {
-        const sut = new LRUBuffer<number>(0);
-        expect(sut.write([1])).toBe(0);
-        expect(sut.read([0])).toBe(0);
-    });
-
-    test("LRUBuffer read from empty buffer should return zero elements", () => {
-        const sut = new LRUBuffer<number>(capacity);
-        const readArr = new Array<number>(capacity);
-        expect(sut.read(readArr)).toBe(0);
-    });
-
-    test("LRUBuffer forEach should apply function to every element in the buffer", () => {
-       const sut = new LRUBuffer<number>(capacity);
-       const es = [] as number[];
-       sut.write([0]);
-       sut.forEach(e => es.push(e));
-       expect(es).toEqual([0]);
-
-       const es2 = [] as number[];
-       sut.write([1, 2, 3, 4]);
-       sut.forEach(e => es2.push(e));
-       expect(es2).toEqual([0, 1, 2, 3, 4]);
-
-        const es3 = [] as number[];
-        sut.write([5, 6]);
-        sut.forEach(e => es3.push(e));
-        expect(es3).toEqual([2, 3, 4, 5, 6]);
-    });
-
-    test("LRUBuffer forEach on empty buffer should do nothing", () => {
-        const sut = new LRUBuffer<number>(capacity);
-        const es = [] as number[];
-        sut.forEach(e => es.push(e));
-        expect(es.length).toBe(0);
-    });
-
-    test("LRUBuffer should contain zero items when cleared", () => {
-        const sut = new LRUBuffer<number>(capacity);
-        const writeArr = createSequentialArray(capacity);
-        const readArr = createEmptyArray(capacity);
-        sut.write(writeArr);
-        sut.clear();
-        expect(sut.len()).toBe(0);
-        expect(sut.read(readArr)).toBe(0);
-        expect(readArr).toEqual(createEmptyArray(capacity));
-    });
-});
-
-const createEmptyArray = (len: number): Array<number> => {
-    return new Array<number>(len);
-}
-
-const createSequentialArray = (len: number): Array<number> => {
-    const arr = new Array<number>(len);
-    for (let i = 0; i < arr.length; i++)
-        arr[i] = i;
-    return arr;
-}

package/test/buffer/timebuffer.test.ts

@@ -1,115 +0,0 @@
-import {TimeBuffer} from "../../src";
-import {createEmptyArray, createSequentialArray} from "./common";
-
-describe("Testsuite for TimeBuffer", () => {
-    const maxAge = 1000;
-    let tb: TimeBuffer<number>;
-
-    beforeEach(() => {
-        tb = new TimeBuffer<number>(maxAge); // no older than 1000 ms
-    });
-
-    test("TimeBuffer length", async () => {
-        expect(tb.len()).toBe(0);
-        for (let i = 0; i < 10; i++) {
-            expect(tb.write([i])).toBe(1);
-            expect(tb.len()).toBe(i + 1);
-        }
-
-        await delay(maxAge + 500).then(() => {
-            expect(tb.len()).toBe(0);
-        });
-    });
-
-    test("TimeBuffer capacity", () => {
-        expect(tb.cap()).toBe(Number.POSITIVE_INFINITY);
-    });
-
-    test("TimeBuffer elements should expire when they reach their maxAge", async () => {
-        // add 10 items
-        for (let i = 0; i < 10; i++) {
-            expect(tb.write([i])).toBe(1);
-            expect(tb.len()).toBe(i + 1);
-        }
-
-        // give elements some time to "age"
-        await delay(500).then(() => {
-
-            // all items should still be in range
-            expect(tb.len()).toBe(10);
-
-            // add 10 more items
-            for (let i = 0; i < 5; i++) {
-                expect(tb.write([i])).toBe(1);
-                expect(tb.len()).toBe(10 + i + 1);
-            }
-        });
-
-        // the first 10 items should now be removed, there are 5 items remaining
-        await delay(800).then(() => {
-            expect(tb.len()).toBe(5);
-        });
-    });
-
-    test("TimeBuffer read should return items up to maxAge ", async () => {
-        const w1 = createSequentialArray(10);
-        expect(tb.write(w1)).toBe(10);
-        const r1 = createEmptyArray(10);
-        expect(tb.read(r1)).toBe(10);
-        for (let i = 0; i < 10; i++)
-            expect(w1[i]).toBe(r1[i]);
-
-        await delay(500).then(() => {
-            const r2 = createEmptyArray(10);
-            expect(tb.read(r2)).toBe(10);
-            for (let i = 0; i < 10; i++)
-                expect(w1[i]).toBe(r2[i]);
-
-            const w2 = createSequentialArray(5);
-            expect(tb.write(w2)).toBe(5);
-            const r3 = createEmptyArray(15);
-            expect(tb.read(r3)).toBe(15);
-            for (let i = 0; i < 15; i++)
-                if (i < 10)
-                    expect(r3[i]).toBe(w1[i]);
-                else
-                    expect(r3[i]).toBe(w2[i - 10]);
-        });
-    });
-
-    test("TimeBuffer read on empty should return no item", () => {
-        const r1 = createEmptyArray(10);
-        expect(tb.read(r1)).toBe(0);
-        expect(tb.read([])).toBe(0);
-    });
-
-    test("TimeBuffer forEach() should only be invoked on valid items", async () => {
-        const w1 = createSequentialArray(10);
-        expect(tb.write(w1)).toBe(10);
-        const r2 = [] as number[];
-        tb.forEach(e => r2.push(e));
-        expect(r2.length).toBe(10);
-
-        await delay(500).then(() => {
-            const w2 = createSequentialArray(5);
-            expect(tb.write(w2)).toBe(5);
-            const r3 = [] as number[]
-            tb.forEach(e => r3.push(e));
-            expect(r3.length).toBe(15);
-        });
-
-        await delay(800).then(() => {
-            const r4 = [] as number[];
-            tb.forEach(e => r4.push(e));
-            expect(r4.length).toBe(5);
-        })
-    })
-});
-
-function delay(ms: number): Promise<void> {
-    return new Promise<void>(resolve => {
-        setTimeout(() => {
-            resolve();
-        }, ms);
-    })
-}