gingersnap 0.22.0

package/socket.cjs

@@ -0,0 +1,239 @@
+'use strict';
+
+var _tslib = require('./_virtual/_tslib.cjs');
+var AbortError = require('./errors/AbortError.cjs');
+var FutureCancelled = require('./errors/FutureCancelled.cjs');
+var NetworkError = require('./errors/NetworkError.cjs');
+require('./networking/decorators/options.cjs');
+require('./networking/decorators/requests.cjs');
+var http = require('./networking/http.cjs');
+require('ramda');
+require('uuid');
+var stream = require('./stream.cjs');
+var future = require('./future/future.cjs');
+var synchronize = require('./synchronize.cjs');
+var stream_state = require('./stream/state.cjs');
+var WebSocket = require('modern-isomorphic-ws');
+require('./data-structures/object/WatchableObject.cjs');
+require('object-hash');
+var Queue = require('./data-structures/object/Queue.cjs');
+var Pair = require('./data-structures/array/Pair.cjs');
+
+/**
+ * Future-based web sockets
+ */
+class StreamableWebSocket {
+    constructor(url, decoder, { retryOnDisconnect, cacheSize, cacheExpiryPeriod, exponentialFactor, backoffPeriodMs, } = {}, maxReconnectAttempt = 3) {
+        this.maxReconnectAttempt = maxReconnectAttempt;
+        this.connectionAttemptCount = 0;
+        this.signal = new AbortController().signal;
+        this.decoder = decoder;
+        this.socketListeners = [];
+        this.url = url;
+        this.cacheSize = cacheSize !== null && cacheSize !== void 0 ? cacheSize : 10000;
+        this.manuallyClosed = false;
+        this.retryOnDisconnect = retryOnDisconnect !== null && retryOnDisconnect !== void 0 ? retryOnDisconnect : true;
+        this.exponentialFactor = exponentialFactor !== null && exponentialFactor !== void 0 ? exponentialFactor : 2;
+        this.backoffPeriodMs = backoffPeriodMs !== null && backoffPeriodMs !== void 0 ? backoffPeriodMs : 10;
+        this.backoffPeriods = -1;
+        this.messageQueues = [];
+        this.evt = new EventTarget();
+        this.dataReadyEvent = new synchronize.FutureEvent();
+        this.dataProcessingLock = new synchronize.Lock();
+    }
+    get opened() {
+        return this.socket && this.socket.readyState === WebSocket.OPEN;
+    }
+    get closed() {
+        return this.socket && this.socket.readyState === WebSocket.CLOSED;
+    }
+    /**
+     * opens the current web socket connection
+     */
+    open() {
+        var _a;
+        if (!this.openFuture || ((_a = this.openFuture) === null || _a === void 0 ? void 0 : _a.failed)) {
+            this.closeFuture = new future.Future((resolve, reject, signal) => {
+                this.signal.addEventListener("abort", () => {
+                    resolve();
+                });
+                signal.onabort = () => {
+                    this.signal.removeEventListener("abort", resolve);
+                    reject(new AbortError.AbortError());
+                };
+            }).schedule();
+            this.openFuture = new future.Future((resolve, reject, signal) => {
+                const functor = () => {
+                    this.close();
+                };
+                signal.addEventListener("abort", functor);
+                let retrying = false;
+                const cancelError = this.addEventListener("error", () => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (this.retryOnDisconnect && !signal.aborted && this.connectionAttemptCount < this.maxReconnectAttempt) {
+                        this.connectionAttemptCount++;
+                        retrying = true;
+                        (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.close();
+                        yield future.Future.sleep({
+                            milliseconds: this.backoffPeriodMs * Math.pow(this.exponentialFactor, ++this.backoffPeriods),
+                        });
+                        this.createSocket();
+                    }
+                    else {
+                        this.connectionAttemptCount = 0;
+                        retrying = false;
+                        cancelError();
+                        cancelOpen();
+                        reject(new NetworkError.NetworkError(http.HTTPStatus.EXPECTATION_FAILED));
+                        (_b = this.getSocket()) === null || _b === void 0 ? void 0 : _b.close();
+                    }
+                }));
+                const cancelOpen = this.addEventListener("open", () => {
+                    this.connectionAttemptCount = 0;
+                    this.backoffPeriods = -1;
+                    retrying = false;
+                    resolve();
+                    signal.removeEventListener("abort", functor);
+                    cancelError();
+                    cancelOpen();
+                });
+                const cancelClose = this.addEventListener("close", () => {
+                    if (retrying)
+                        return;
+                    if (!this.manuallyClosed && this.retryOnDisconnect && !signal.aborted) {
+                        delete this.openFuture;
+                        cancelError();
+                        cancelOpen();
+                        cancelClose();
+                        this.open()
+                            .thenApply(() => resolve())
+                            .catch(reject);
+                    }
+                    else {
+                        retrying = false;
+                        this.signal.dispatchEvent(new CustomEvent("abort"));
+                        cancelQueue();
+                        reject(new NetworkError.NetworkError(http.HTTPStatus.EXPECTATION_FAILED));
+                    }
+                });
+                const cancelQueue = this.addEventListener("message", (evt) => {
+                    const data = evt.data instanceof ArrayBuffer ? evt.data : new TextEncoder().encode(evt.data).buffer;
+                    const result = this.decoder.decode(data);
+                    for (const value of this.messageQueues) {
+                        if (value instanceof Pair.Pair && value.second(result)) {
+                            value.first.enqueue(result);
+                        }
+                        else if (Array.isArray(value)) {
+                            value.push(result);
+                        }
+                    }
+                    this.dataReadyEvent.set();
+                });
+                this.createSocket();
+            });
+        }
+        return this.openFuture;
+    }
+    /**
+     * Wait for the socket connection closed.
+     * @remark
+     * This doesn't actually attempt to close the socket, only waits for the connection to close
+     */
+    closedFuture() {
+        if (this.closeFuture)
+            return this.closeFuture;
+        throw new NetworkError.NetworkError(http.HTTPStatus.FORBIDDEN, "Stream not opened");
+    }
+    /**
+     * Closes the socket if currently open
+     */
+    close() {
+        var _a;
+        this.manuallyClosed = true;
+        (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.close();
+        this.messageQueues = [];
+        this.signal.dispatchEvent(new CustomEvent("abort"));
+    }
+    /**
+     * Sends data via socket
+     * @param data
+     */
+    send(data) {
+        var _a;
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.send(data instanceof Blob ? yield data.arrayBuffer() : data);
+        });
+    }
+    streamView(lens, objectMaxSize, expiryPeriod) {
+        const queue = new Queue.Queue(objectMaxSize, expiryPeriod);
+        const tuple = Pair.pair(queue, lens);
+        this.messageQueues.push(tuple);
+        return queue.streamEntries.cancelOnSignal(this.signal).onCompletion(() => {
+            this.messageQueues = this.messageQueues.filter((v) => v !== tuple);
+        });
+    }
+    /**
+     * Gets the stream for messages received via this socket
+     */
+    stream() {
+        const queue = [];
+        this.messageQueues.push(queue);
+        return new stream.Stream((signal) => {
+            const data = queue.shift();
+            if (data === undefined) {
+                this.dataReadyEvent.clear();
+                return this.dataReadyEvent
+                    .wait()
+                    .thenApply(() => queue.shift())
+                    .catch((error) => {
+                    if (error instanceof FutureCancelled.FutureCancelled) {
+                        return new stream_state.ExecutorState(true);
+                    }
+                    throw error;
+                })
+                    .registerSignal(signal);
+            }
+            return data;
+        })
+            .cancelOnSignal(this.signal)
+            .onCompletion(() => {
+            this.messageQueues = this.messageQueues.filter((v) => v !== queue);
+        });
+    }
+    addEventListener(type, functor) {
+        this.socketListeners.push([type, functor]);
+        if (this.socket) {
+            this.socket.addEventListener(type, functor);
+        }
+        return () => {
+            this.socketListeners = this.socketListeners.filter(([t, f]) => f !== functor && t !== type);
+            if (this.socket)
+                this.socket.removeEventListener(type, functor);
+        };
+    }
+    createSocket() {
+        const socket = new WebSocket(this.url);
+        socket.binaryType = "arraybuffer";
+        this.socketListeners.forEach(([type, functor]) => socket.addEventListener(type, functor));
+        this.socket = socket;
+        future.Future.sleep(2)
+            .thenApply(() => {
+            if (socket.readyState === 0) {
+                socket.close();
+                const evt = new Event("error");
+                this.socketListeners.forEach(([type, functor]) => {
+                    if (type === "error") {
+                        functor(evt);
+                    }
+                });
+            }
+        })
+            .schedule();
+        return socket;
+    }
+    getSocket() {
+        return this.socket;
+    }
+}
+
+exports.StreamableWebSocket = StreamableWebSocket;

package/socket.d.ts

@@ -0,0 +1,65 @@
+import { Stream } from "./stream";
+import { Future, WaitPeriod } from "./future";
+import { Decoder } from "./data/decoders";
+interface WebSocketConfiguration {
+    retryOnDisconnect?: boolean;
+    cacheSize?: number;
+    cacheExpiryPeriod?: WaitPeriod;
+    exponentialFactor?: number;
+    backoffPeriodMs?: number;
+}
+/**
+ * Future-based web sockets
+ */
+export declare class StreamableWebSocket<T> {
+    private readonly maxReconnectAttempt;
+    private readonly retryOnDisconnect;
+    private openFuture?;
+    private closeFuture?;
+    private socketListeners;
+    private messageQueues;
+    private readonly url;
+    private socket?;
+    private manuallyClosed;
+    private readonly cacheSize;
+    private readonly backoffPeriodMs;
+    private readonly exponentialFactor;
+    private readonly signal;
+    private backoffPeriods;
+    private readonly evt;
+    private readonly dataReadyEvent;
+    private readonly dataProcessingLock;
+    readonly decoder: Decoder<T>;
+    private connectionAttemptCount;
+    constructor(url: string, decoder: Decoder<T>, { retryOnDisconnect, cacheSize, cacheExpiryPeriod, exponentialFactor, backoffPeriodMs, }?: WebSocketConfiguration, maxReconnectAttempt?: number);
+    get opened(): boolean;
+    get closed(): boolean;
+    /**
+     * opens the current web socket connection
+     */
+    open(): Future<void>;
+    /**
+     * Wait for the socket connection closed.
+     * @remark
+     * This doesn't actually attempt to close the socket, only waits for the connection to close
+     */
+    closedFuture(): Future<void>;
+    /**
+     * Closes the socket if currently open
+     */
+    close(): void;
+    /**
+     * Sends data via socket
+     * @param data
+     */
+    send(data: string | ArrayBufferView | Blob | ArrayBufferLike): Promise<void>;
+    streamView(lens: (v: T) => boolean, objectMaxSize?: number, expiryPeriod?: WaitPeriod): Stream<T>;
+    /**
+     * Gets the stream for messages received via this socket
+     */
+    stream(): Stream<T>;
+    private addEventListener;
+    private createSocket;
+    private getSocket;
+}
+export {};

package/socket.mjs

@@ -0,0 +1,237 @@
+import { __awaiter } from './_virtual/_tslib.mjs';
+import { AbortError } from './errors/AbortError.mjs';
+import { FutureCancelled } from './errors/FutureCancelled.mjs';
+import { NetworkError } from './errors/NetworkError.mjs';
+import './networking/decorators/options.mjs';
+import './networking/decorators/requests.mjs';
+import { HTTPStatus } from './networking/http.mjs';
+import 'ramda';
+import 'uuid';
+import { Stream } from './stream.mjs';
+import { Future } from './future/future.mjs';
+import { FutureEvent, Lock } from './synchronize.mjs';
+import { ExecutorState } from './stream/state.mjs';
+import WebSocket from 'modern-isomorphic-ws';
+import './data-structures/object/WatchableObject.mjs';
+import 'object-hash';
+import { Queue } from './data-structures/object/Queue.mjs';
+import { Pair, pair } from './data-structures/array/Pair.mjs';
+
+/**
+ * Future-based web sockets
+ */
+class StreamableWebSocket {
+    constructor(url, decoder, { retryOnDisconnect, cacheSize, cacheExpiryPeriod, exponentialFactor, backoffPeriodMs, } = {}, maxReconnectAttempt = 3) {
+        this.maxReconnectAttempt = maxReconnectAttempt;
+        this.connectionAttemptCount = 0;
+        this.signal = new AbortController().signal;
+        this.decoder = decoder;
+        this.socketListeners = [];
+        this.url = url;
+        this.cacheSize = cacheSize !== null && cacheSize !== void 0 ? cacheSize : 10000;
+        this.manuallyClosed = false;
+        this.retryOnDisconnect = retryOnDisconnect !== null && retryOnDisconnect !== void 0 ? retryOnDisconnect : true;
+        this.exponentialFactor = exponentialFactor !== null && exponentialFactor !== void 0 ? exponentialFactor : 2;
+        this.backoffPeriodMs = backoffPeriodMs !== null && backoffPeriodMs !== void 0 ? backoffPeriodMs : 10;
+        this.backoffPeriods = -1;
+        this.messageQueues = [];
+        this.evt = new EventTarget();
+        this.dataReadyEvent = new FutureEvent();
+        this.dataProcessingLock = new Lock();
+    }
+    get opened() {
+        return this.socket && this.socket.readyState === WebSocket.OPEN;
+    }
+    get closed() {
+        return this.socket && this.socket.readyState === WebSocket.CLOSED;
+    }
+    /**
+     * opens the current web socket connection
+     */
+    open() {
+        var _a;
+        if (!this.openFuture || ((_a = this.openFuture) === null || _a === void 0 ? void 0 : _a.failed)) {
+            this.closeFuture = new Future((resolve, reject, signal) => {
+                this.signal.addEventListener("abort", () => {
+                    resolve();
+                });
+                signal.onabort = () => {
+                    this.signal.removeEventListener("abort", resolve);
+                    reject(new AbortError());
+                };
+            }).schedule();
+            this.openFuture = new Future((resolve, reject, signal) => {
+                const functor = () => {
+                    this.close();
+                };
+                signal.addEventListener("abort", functor);
+                let retrying = false;
+                const cancelError = this.addEventListener("error", () => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (this.retryOnDisconnect && !signal.aborted && this.connectionAttemptCount < this.maxReconnectAttempt) {
+                        this.connectionAttemptCount++;
+                        retrying = true;
+                        (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.close();
+                        yield Future.sleep({
+                            milliseconds: this.backoffPeriodMs * Math.pow(this.exponentialFactor, ++this.backoffPeriods),
+                        });
+                        this.createSocket();
+                    }
+                    else {
+                        this.connectionAttemptCount = 0;
+                        retrying = false;
+                        cancelError();
+                        cancelOpen();
+                        reject(new NetworkError(HTTPStatus.EXPECTATION_FAILED));
+                        (_b = this.getSocket()) === null || _b === void 0 ? void 0 : _b.close();
+                    }
+                }));
+                const cancelOpen = this.addEventListener("open", () => {
+                    this.connectionAttemptCount = 0;
+                    this.backoffPeriods = -1;
+                    retrying = false;
+                    resolve();
+                    signal.removeEventListener("abort", functor);
+                    cancelError();
+                    cancelOpen();
+                });
+                const cancelClose = this.addEventListener("close", () => {
+                    if (retrying)
+                        return;
+                    if (!this.manuallyClosed && this.retryOnDisconnect && !signal.aborted) {
+                        delete this.openFuture;
+                        cancelError();
+                        cancelOpen();
+                        cancelClose();
+                        this.open()
+                            .thenApply(() => resolve())
+                            .catch(reject);
+                    }
+                    else {
+                        retrying = false;
+                        this.signal.dispatchEvent(new CustomEvent("abort"));
+                        cancelQueue();
+                        reject(new NetworkError(HTTPStatus.EXPECTATION_FAILED));
+                    }
+                });
+                const cancelQueue = this.addEventListener("message", (evt) => {
+                    const data = evt.data instanceof ArrayBuffer ? evt.data : new TextEncoder().encode(evt.data).buffer;
+                    const result = this.decoder.decode(data);
+                    for (const value of this.messageQueues) {
+                        if (value instanceof Pair && value.second(result)) {
+                            value.first.enqueue(result);
+                        }
+                        else if (Array.isArray(value)) {
+                            value.push(result);
+                        }
+                    }
+                    this.dataReadyEvent.set();
+                });
+                this.createSocket();
+            });
+        }
+        return this.openFuture;
+    }
+    /**
+     * Wait for the socket connection closed.
+     * @remark
+     * This doesn't actually attempt to close the socket, only waits for the connection to close
+     */
+    closedFuture() {
+        if (this.closeFuture)
+            return this.closeFuture;
+        throw new NetworkError(HTTPStatus.FORBIDDEN, "Stream not opened");
+    }
+    /**
+     * Closes the socket if currently open
+     */
+    close() {
+        var _a;
+        this.manuallyClosed = true;
+        (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.close();
+        this.messageQueues = [];
+        this.signal.dispatchEvent(new CustomEvent("abort"));
+    }
+    /**
+     * Sends data via socket
+     * @param data
+     */
+    send(data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.getSocket()) === null || _a === void 0 ? void 0 : _a.send(data instanceof Blob ? yield data.arrayBuffer() : data);
+        });
+    }
+    streamView(lens, objectMaxSize, expiryPeriod) {
+        const queue = new Queue(objectMaxSize, expiryPeriod);
+        const tuple = pair(queue, lens);
+        this.messageQueues.push(tuple);
+        return queue.streamEntries.cancelOnSignal(this.signal).onCompletion(() => {
+            this.messageQueues = this.messageQueues.filter((v) => v !== tuple);
+        });
+    }
+    /**
+     * Gets the stream for messages received via this socket
+     */
+    stream() {
+        const queue = [];
+        this.messageQueues.push(queue);
+        return new Stream((signal) => {
+            const data = queue.shift();
+            if (data === undefined) {
+                this.dataReadyEvent.clear();
+                return this.dataReadyEvent
+                    .wait()
+                    .thenApply(() => queue.shift())
+                    .catch((error) => {
+                    if (error instanceof FutureCancelled) {
+                        return new ExecutorState(true);
+                    }
+                    throw error;
+                })
+                    .registerSignal(signal);
+            }
+            return data;
+        })
+            .cancelOnSignal(this.signal)
+            .onCompletion(() => {
+            this.messageQueues = this.messageQueues.filter((v) => v !== queue);
+        });
+    }
+    addEventListener(type, functor) {
+        this.socketListeners.push([type, functor]);
+        if (this.socket) {
+            this.socket.addEventListener(type, functor);
+        }
+        return () => {
+            this.socketListeners = this.socketListeners.filter(([t, f]) => f !== functor && t !== type);
+            if (this.socket)
+                this.socket.removeEventListener(type, functor);
+        };
+    }
+    createSocket() {
+        const socket = new WebSocket(this.url);
+        socket.binaryType = "arraybuffer";
+        this.socketListeners.forEach(([type, functor]) => socket.addEventListener(type, functor));
+        this.socket = socket;
+        Future.sleep(2)
+            .thenApply(() => {
+            if (socket.readyState === 0) {
+                socket.close();
+                const evt = new Event("error");
+                this.socketListeners.forEach(([type, functor]) => {
+                    if (type === "error") {
+                        functor(evt);
+                    }
+                });
+            }
+        })
+            .schedule();
+        return socket;
+    }
+    getSocket() {
+        return this.socket;
+    }
+}
+
+export { StreamableWebSocket };

package/store.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var manager = require('./data/store/manager.cjs');
+var web = require('./data/store/web.cjs');
+var json = require('./data/store/json.cjs');
+
+
+
+exports.CacheManager = manager.CacheManager;
+exports.LocalWebStore = web.LocalWebStore;
+exports.SessionWebStore = web.SessionWebStore;
+exports.JSONFileStore = json.JSONFileStore;

package/store.mjs

@@ -0,0 +1,3 @@
+export { CacheManager } from './data/store/manager.mjs';
+export { LocalWebStore, SessionWebStore } from './data/store/web.mjs';
+export { JSONFileStore } from './data/store/json.mjs';