gingersnap 0.22.0

package/data-structures/object/WatchableObject.mjs

@@ -0,0 +1,230 @@
+import { __awaiter, __asyncValues } from '../../_virtual/_tslib.mjs';
+import { WaitableObject } from './WaitableObject.mjs';
+import { Future } from '../../future/future.mjs';
+import * as R from 'ramda';
+import { FutureEvent } from '../../synchronize.mjs';
+import { Stream } from '../../stream.mjs';
+import { ExecutorState } from '../../stream/state.mjs';
+import { SimpleQueue } from './SimpleQueue.mjs';
+
+var WatchableObjectOperations;
+(function (WatchableObjectOperations) {
+    WatchableObjectOperations[WatchableObjectOperations["DELETE"] = 0] = "DELETE";
+    WatchableObjectOperations[WatchableObjectOperations["GET"] = 1] = "GET";
+    WatchableObjectOperations[WatchableObjectOperations["SET"] = 2] = "SET";
+    WatchableObjectOperations[WatchableObjectOperations["CLEAR"] = 3] = "CLEAR";
+    WatchableObjectOperations[WatchableObjectOperations["VALUES"] = 4] = "VALUES";
+})(WatchableObjectOperations || (WatchableObjectOperations = {}));
+class WatchableObject extends WaitableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.getListeners = [];
+        this.setListeners = [];
+        this.deleteListeners = [];
+        this.clearListeners = [];
+        this.valuesListeners = [];
+    }
+    /**
+     * Ingest data from the given stream into the queue. The future returned is
+     * already scheduled to execute in the background. However, you can cancel
+     * ingestion at anytime by cancelling the returned future
+     *
+     * Important Note:
+     * - Cancelling the ingestion does not kill the stream, only stops
+     * monitoring the stream for incoming data
+     * - If ingestion is cancelled and data had been retrieved at that period, the
+     * data will discarded
+     * @param stream input data stream
+     * @param keyExtractor used to get the key for storing the incoming data
+     */
+    ingest(stream, keyExtractor) {
+        return this.ingestStream(stream, (data) => this.set(keyExtractor(data), data));
+    }
+    clone() {
+        return super.clone();
+    }
+    /**
+     * Stream of changes made to the object via SET, DELETE or CLEAR commands
+     */
+    changeStream() {
+        const evt = new FutureEvent();
+        const queue = new SimpleQueue();
+        const cancelSet = this.onSet((key, oldValue, newValue) => {
+            queue.enqueue({
+                type: WatchableObjectOperations.SET,
+                key,
+                oldValue,
+                newValue,
+            });
+            evt.set();
+        });
+        const cancelDelete = this.onDelete((key, oldValue) => {
+            queue.enqueue({
+                type: WatchableObjectOperations.DELETE,
+                key,
+                oldValue,
+            });
+            evt.set();
+        });
+        const cancelClear = this.onClear(() => {
+            queue.enqueue({
+                type: WatchableObjectOperations.CLEAR,
+                key: "*",
+            });
+            evt.set();
+        });
+        const cleanup = R.once(() => {
+            cancelClear();
+            cancelSet();
+            cancelDelete();
+        });
+        return new Stream((signal) => __awaiter(this, void 0, void 0, function* () {
+            signal.onabort = cleanup;
+            while (queue.empty && !signal.aborted) {
+                yield evt.wait();
+                evt.clear();
+            }
+            if (signal.aborted) {
+                return new ExecutorState(true);
+            }
+            return queue.dequeue();
+        }));
+    }
+    /**
+     * Listens whenever a value is retrieved from this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onGet(listener) {
+        this.getListeners.push(listener);
+        return () => {
+            this.getListeners = this.getListeners.filter((v) => v !== listener);
+        };
+    }
+    /**
+     * Listens whenever a property is added or updated on this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onSet(listener) {
+        this.setListeners.push(listener);
+        return () => {
+            this.setListeners = this.setListeners.filter((v) => v !== listener);
+        };
+    }
+    /**
+     * Listens whenever a property is deleted from this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onDelete(listener) {
+        this.deleteListeners.push(listener);
+        return () => {
+            this.deleteListeners = this.deleteListeners.filter((v) => v !== listener);
+        };
+    }
+    /**
+     * Listens whenever this object is wiped clean
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onClear(listener) {
+        this.clearListeners.push(listener);
+        return () => {
+            this.clearListeners = this.clearListeners.filter((v) => v !== listener);
+        };
+    }
+    /**
+     * Listens whenever the values() method is invoked on this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onValues(listener) {
+        this.valuesListeners.push(listener);
+        return () => {
+            this.valuesListeners = this.valuesListeners.filter((v) => v !== listener);
+        };
+    }
+    get(key, defaultValue) {
+        Future.sleep(1)
+            .thenApply(() => this.getListeners.forEach((listener) => listener(key)))
+            .run();
+        return super.get(key, defaultValue);
+    }
+    set(key, value, expiryPeriod) {
+        const oldValue = this.get(key);
+        super.set(key, value, expiryPeriod);
+        this.setListeners.forEach((listener) => listener(key, oldValue, value));
+    }
+    delete(key) {
+        const oldValue = this.get(key);
+        super.delete(key);
+        if (oldValue !== undefined)
+            this.deleteListeners.forEach((listener) => listener(key, oldValue));
+    }
+    clear() {
+        super.clear();
+        this.clearListeners.forEach((listener) => listener());
+    }
+    await(key, abort) {
+        return super.await(key, abort).thenApply((value) => {
+            Future.sleep(1)
+                .thenApply(() => this.getListeners.forEach((listener) => listener(key)))
+                .run();
+            return value.value;
+        });
+    }
+    on(key, callback, multiCall = true) {
+        return super.on(key, (v) => {
+            Future.sleep(1)
+                .thenApply(() => this.getListeners.forEach((listener) => listener(key)))
+                .run();
+            callback(v);
+        }, multiCall);
+    }
+    values(copy) {
+        Future.sleep(1)
+            .thenApply(() => this.valuesListeners.forEach((listener) => listener()))
+            .run();
+        return super.values(copy);
+    }
+    ingestStream(stream, handler) {
+        return Future.of((_, __, signal) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a;) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    try {
+                        const data = _c;
+                        while (!signal.aborted && this.objectMaxSize && this.size() === this.objectMaxSize) {
+                            yield Future.of((resolve, _, signal) => {
+                                const cancel = this.onDelete(() => {
+                                    cancel();
+                                    resolve(null);
+                                });
+                                signal.onabort = cancel;
+                            }).registerSignal(signal);
+                        }
+                        if (signal.aborted) {
+                            break;
+                        }
+                        handler(data);
+                    }
+                    finally {
+                        _d = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        })).schedule();
+    }
+}
+
+export { WatchableObject, WatchableObjectOperations };

package/data-structures/object/index.d.ts

@@ -0,0 +1,7 @@
+export { WatchableObject, WatchableChange, WatchableObjectOperations, Configuration } from "./WatchableObject";
+export { WaitableObject } from "./WaitableObject";
+export { CyclicalObject } from "./CyclicalObject";
+export { TimeableObject } from "./TimeableObject";
+export { Queue } from "./Queue";
+export { BufferQueue } from "./BufferQueue";
+export { SimpleQueue } from "./SimpleQueue";

package/data-structures/object.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var WatchableObject = require('./object/WatchableObject.cjs');
+var WaitableObject = require('./object/WaitableObject.cjs');
+var CyclicalObject = require('./object/CyclicalObject.cjs');
+var TimeableObject = require('./object/TimeableObject.cjs');
+var Queue = require('./object/Queue.cjs');
+var BufferQueue = require('./object/BufferQueue.cjs');
+var SimpleQueue = require('./object/SimpleQueue.cjs');
+
+
+
+exports.WatchableObject = WatchableObject.WatchableObject;
+Object.defineProperty(exports, 'WatchableObjectOperations', {
+	enumerable: true,
+	get: function () { return WatchableObject.WatchableObjectOperations; }
+});
+exports.WaitableObject = WaitableObject.WaitableObject;
+exports.CyclicalObject = CyclicalObject.CyclicalObject;
+exports.TimeableObject = TimeableObject.TimeableObject;
+exports.Queue = Queue.Queue;
+exports.BufferQueue = BufferQueue.BufferQueue;
+exports.SimpleQueue = SimpleQueue.SimpleQueue;

package/data-structures/object.mjs

@@ -0,0 +1,7 @@
+export { WatchableObject, WatchableObjectOperations } from './object/WatchableObject.mjs';
+export { WaitableObject } from './object/WaitableObject.mjs';
+export { CyclicalObject } from './object/CyclicalObject.mjs';
+export { TimeableObject } from './object/TimeableObject.mjs';
+export { Queue } from './object/Queue.mjs';
+export { BufferQueue } from './object/BufferQueue.mjs';
+export { SimpleQueue } from './object/SimpleQueue.mjs';

package/errors/AbortError.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+/**
+ * Thrown to indicate some async operation was aborted
+ */
+class AbortError extends Error {
+}
+
+exports.AbortError = AbortError;

package/errors/AbortError.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Thrown to indicate some async operation was aborted
+ */
+export declare class AbortError extends Error {
+}

package/errors/AbortError.mjs

@@ -0,0 +1,7 @@
+/**
+ * Thrown to indicate some async operation was aborted
+ */
+class AbortError extends Error {
+}
+
+export { AbortError };

package/errors/CallExecutionError.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Thrown when a network call fails to be executed successfully
+ */
+class CallExecutionError extends Error {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+
+exports.CallExecutionError = CallExecutionError;

package/errors/CallExecutionError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown when a network call fails to be executed successfully
+ */
+export declare class CallExecutionError extends Error {
+    readonly response?: Response;
+    constructor(message: string, response?: Response);
+}

package/errors/CallExecutionError.mjs

@@ -0,0 +1,11 @@
+/**
+ * Thrown when a network call fails to be executed successfully
+ */
+class CallExecutionError extends Error {
+    constructor(message, response) {
+        super(message);
+        this.response = response;
+    }
+}
+
+export { CallExecutionError };

package/errors/FutureCancelled.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var FutureError = require('./FutureError.cjs');
+
+/**
+ * Error thrown when a future is cancelled
+ */
+class FutureCancelled extends FutureError.FutureError {
+}
+
+exports.FutureCancelled = FutureCancelled;

package/errors/FutureCancelled.d.ts

@@ -0,0 +1,6 @@
+import { FutureError } from "./FutureError";
+/**
+ * Error thrown when a future is cancelled
+ */
+export declare class FutureCancelled extends FutureError {
+}

package/errors/FutureCancelled.mjs

@@ -0,0 +1,9 @@
+import { FutureError } from './FutureError.mjs';
+
+/**
+ * Error thrown when a future is cancelled
+ */
+class FutureCancelled extends FutureError {
+}
+
+export { FutureCancelled };

package/errors/FutureError.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var AbortError = require('./AbortError.cjs');
+
+/**
+ * Any type of error raised from a future
+ */
+class FutureError extends AbortError.AbortError {
+}
+
+exports.FutureError = FutureError;

package/errors/FutureError.d.ts

@@ -0,0 +1,6 @@
+import { AbortError } from "./AbortError";
+/**
+ * Any type of error raised from a future
+ */
+export declare class FutureError extends AbortError {
+}

package/errors/FutureError.mjs

@@ -0,0 +1,9 @@
+import { AbortError } from './AbortError.mjs';
+
+/**
+ * Any type of error raised from a future
+ */
+class FutureError extends AbortError {
+}
+
+export { FutureError };

package/errors/IllegalArgumentsError.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Thrown to indicate that a method/function has been passed an illegal or inappropriate argument
+ */
+class IllegalArgumentsError extends Error {
+    constructor(args) {
+        super(`Received invalid arguments of type ${args.map((arg) => typeof arg).join(",")}`);
+        this.arguments = args;
+    }
+}
+
+exports.IllegalArgumentsError = IllegalArgumentsError;

package/errors/IllegalArgumentsError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown to indicate that a method/function has been passed an illegal or inappropriate argument
+ */
+export declare class IllegalArgumentsError extends Error {
+    readonly arguments: any[];
+    constructor(args: any[]);
+}

package/errors/IllegalArgumentsError.mjs

@@ -0,0 +1,11 @@
+/**
+ * Thrown to indicate that a method/function has been passed an illegal or inappropriate argument
+ */
+class IllegalArgumentsError extends Error {
+    constructor(args) {
+        super(`Received invalid arguments of type ${args.map((arg) => typeof arg).join(",")}`);
+        this.arguments = args;
+    }
+}
+
+export { IllegalArgumentsError };

package/errors/IllegalOperationError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class IllegalOperationError extends Error {
+}
+
+exports.IllegalOperationError = IllegalOperationError;

package/errors/IllegalOperationError.d.ts

@@ -0,0 +1,2 @@
+export declare class IllegalOperationError extends Error {
+}

package/errors/IllegalOperationError.mjs

@@ -0,0 +1,4 @@
+class IllegalOperationError extends Error {
+}
+
+export { IllegalOperationError };

package/errors/InvalidType.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class InvalidType extends Error {
+}
+
+exports.InvalidType = InvalidType;

package/errors/InvalidType.d.ts

@@ -0,0 +1,2 @@
+export declare class InvalidType extends Error {
+}

package/errors/InvalidType.mjs

@@ -0,0 +1,4 @@
+class InvalidType extends Error {
+}
+
+export { InvalidType };

package/errors/InvalidValue.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var ParsingError = require('./ParsingError.cjs');
+
+class InvalidValue extends ParsingError.ParsingError {
+    constructor(message) {
+        super([], message);
+    }
+}
+
+exports.InvalidValue = InvalidValue;

package/errors/InvalidValue.d.ts

@@ -0,0 +1,4 @@
+import { ParsingError } from "./ParsingError";
+export declare class InvalidValue extends ParsingError {
+    constructor(message?: string);
+}

package/errors/InvalidValue.mjs

@@ -0,0 +1,9 @@
+import { ParsingError } from './ParsingError.mjs';
+
+class InvalidValue extends ParsingError {
+    constructor(message) {
+        super([], message);
+    }
+}
+
+export { InvalidValue };

package/errors/MissingArgumentsError.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Thrown to indicate that one or more required arguments of a method/function is missing
+ */
+class MissingArgumentsError extends Error {
+    constructor(args) {
+        super(`Missing the following arguments: ${args.join(",")}`);
+        this.arguments = args;
+    }
+}
+
+exports.MissingArgumentsError = MissingArgumentsError;

package/errors/MissingArgumentsError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown to indicate that one or more required arguments of a method/function is missing
+ */
+export declare class MissingArgumentsError extends Error {
+    readonly arguments: any[];
+    constructor(args: string[]);
+}

package/errors/MissingArgumentsError.mjs

@@ -0,0 +1,11 @@
+/**
+ * Thrown to indicate that one or more required arguments of a method/function is missing
+ */
+class MissingArgumentsError extends Error {
+    constructor(args) {
+        super(`Missing the following arguments: ${args.join(",")}`);
+        this.arguments = args;
+    }
+}
+
+export { MissingArgumentsError };

package/errors/NetworkError.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ *Thrown to indicate some networking issue
+ */
+class NetworkError extends Error {
+    constructor(status, body) {
+        super(body !== null && body !== void 0 ? body : "");
+        this.status = status;
+    }
+}
+
+exports.NetworkError = NetworkError;

package/errors/NetworkError.d.ts

@@ -0,0 +1,8 @@
+import { HTTPStatus } from "../networking/decorators";
+/**
+ *Thrown to indicate some networking issue
+ */
+export declare class NetworkError extends Error {
+    status: HTTPStatus;
+    constructor(status: HTTPStatus, body?: string);
+}

package/errors/NetworkError.mjs

@@ -0,0 +1,11 @@
+/**
+ *Thrown to indicate some networking issue
+ */
+class NetworkError extends Error {
+    constructor(status, body) {
+        super(body !== null && body !== void 0 ? body : "");
+        this.status = status;
+    }
+}
+
+export { NetworkError };

package/errors/NoSuchElement.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class NoSuchElement extends Error {
+}
+
+exports.NoSuchElement = NoSuchElement;

package/errors/NoSuchElement.d.ts

@@ -0,0 +1,2 @@
+export declare class NoSuchElement extends Error {
+}

package/errors/NoSuchElement.mjs

@@ -0,0 +1,4 @@
+class NoSuchElement extends Error {
+}
+
+export { NoSuchElement };

package/errors/NotImplemented.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+/**
+ * Thrown to indicate that the method is not accessible
+ */
+class NotImplemented extends Error {
+}
+
+exports.NotImplemented = NotImplemented;

package/errors/NotImplemented.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Thrown to indicate that the method is not accessible
+ */
+export declare class NotImplemented extends Error {
+}

package/errors/NotImplemented.mjs

@@ -0,0 +1,7 @@
+/**
+ * Thrown to indicate that the method is not accessible
+ */
+class NotImplemented extends Error {
+}
+
+export { NotImplemented };

package/errors/ParsingError.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+class ParsingError extends Error {
+    constructor(records = [], message) {
+        super(message);
+        this.details = records;
+    }
+}
+
+exports.ParsingError = ParsingError;

package/errors/ParsingError.d.ts

@@ -0,0 +1,5 @@
+import { ParseError } from "papaparse";
+export declare class ParsingError extends Error {
+    readonly details: ParseError[];
+    constructor(records?: ParseError[], message?: string);
+}

package/errors/ParsingError.mjs

@@ -0,0 +1,8 @@
+class ParsingError extends Error {
+    constructor(records = [], message) {
+        super(message);
+        this.details = records;
+    }
+}
+
+export { ParsingError };

package/errors/QueueEmptyError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class QueueEmptyError extends Error {
+}
+
+exports.QueueEmptyError = QueueEmptyError;

package/errors/QueueEmptyError.d.ts

@@ -0,0 +1,2 @@
+export declare class QueueEmptyError extends Error {
+}

package/errors/QueueEmptyError.mjs

@@ -0,0 +1,4 @@
+class QueueEmptyError extends Error {
+}
+
+export { QueueEmptyError };