gingersnap 0.22.0

package/data-structures/object/WaitableObject.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var TimeableObject = require('./TimeableObject.cjs');
+var future = require('../../future/future.cjs');
+require('ramda');
+require('../../stream.cjs');
+var uuid = require('uuid');
+
+/**
+ * Object that allows you to wait until property exists, and perform some action on them
+ */
+class WaitableObject extends TimeableObject.TimeableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.listeners = new Map();
+    }
+    /**
+     * Retrieves the value at the given path once it exists
+     * @param key path
+     * @param abort signal to cancel waiting on result
+     */
+    await(key, abort) {
+        if (this.has(key)) {
+            return future.Future.completed(super.get(key));
+        }
+        const guid = uuid.v4();
+        return new future.Future((resolve, reject, signal) => {
+            this.listeners.set(guid, [key, resolve, false]);
+            signal.onabort = () => {
+                this.listeners.delete(guid);
+            };
+        }, abort);
+    }
+    /**
+     * Retrieves the value at the given key once it exists, or the value changes
+     * @param key path
+     * @param callback callback function that is trigger once value exist or is changed
+     * @param multiCall
+     * @returns unsubscribe function
+     */
+    on(key, callback, multiCall = true) {
+        const guid = uuid.v4();
+        this.listeners.set(guid, [key, callback, multiCall]);
+        return () => this.listeners.delete(guid);
+    }
+    set(key, value, expiryPeriod) {
+        super.set(key, value, expiryPeriod);
+        for (const [guid, [k, callback, multiCall]] of this.listeners.entries()) {
+            if (k !== key)
+                continue;
+            callback(value);
+            if (!multiCall)
+                this.listeners.delete(guid);
+        }
+    }
+    clone() {
+        return super.clone();
+    }
+}
+
+exports.WaitableObject = WaitableObject;

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

@@ -0,0 +1,29 @@
+import { TimeableObject } from "./TimeableObject";
+import { Future, WaitPeriod } from "../../future";
+/**
+ * Object that allows you to wait until property exists, and perform some action on them
+ */
+export declare class WaitableObject<T, K> extends TimeableObject<T, K> {
+    /**
+     * Listeners that are waiting for the value at a specific path to exist or updated
+     * @private
+     */
+    private readonly listeners;
+    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    /**
+     * Retrieves the value at the given path once it exists
+     * @param key path
+     * @param abort signal to cancel waiting on result
+     */
+    await(key: T, abort?: AbortSignal): Future<K>;
+    /**
+     * Retrieves the value at the given key once it exists, or the value changes
+     * @param key path
+     * @param callback callback function that is trigger once value exist or is changed
+     * @param multiCall
+     * @returns unsubscribe function
+     */
+    on(key: T, callback: (value: K) => void, multiCall?: boolean): () => boolean;
+    set(key: T, value: K, expiryPeriod?: WaitPeriod): void;
+    clone(): any;
+}

package/data-structures/object/WaitableObject.mjs

@@ -0,0 +1,59 @@
+import { TimeableObject } from './TimeableObject.mjs';
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+import '../../stream.mjs';
+import { v4 } from 'uuid';
+
+/**
+ * Object that allows you to wait until property exists, and perform some action on them
+ */
+class WaitableObject extends TimeableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.listeners = new Map();
+    }
+    /**
+     * Retrieves the value at the given path once it exists
+     * @param key path
+     * @param abort signal to cancel waiting on result
+     */
+    await(key, abort) {
+        if (this.has(key)) {
+            return Future.completed(super.get(key));
+        }
+        const guid = v4();
+        return new Future((resolve, reject, signal) => {
+            this.listeners.set(guid, [key, resolve, false]);
+            signal.onabort = () => {
+                this.listeners.delete(guid);
+            };
+        }, abort);
+    }
+    /**
+     * Retrieves the value at the given key once it exists, or the value changes
+     * @param key path
+     * @param callback callback function that is trigger once value exist or is changed
+     * @param multiCall
+     * @returns unsubscribe function
+     */
+    on(key, callback, multiCall = true) {
+        const guid = v4();
+        this.listeners.set(guid, [key, callback, multiCall]);
+        return () => this.listeners.delete(guid);
+    }
+    set(key, value, expiryPeriod) {
+        super.set(key, value, expiryPeriod);
+        for (const [guid, [k, callback, multiCall]] of this.listeners.entries()) {
+            if (k !== key)
+                continue;
+            callback(value);
+            if (!multiCall)
+                this.listeners.delete(guid);
+        }
+    }
+    clone() {
+        return super.clone();
+    }
+}
+
+export { WaitableObject };

package/data-structures/object/WatchableObject.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var WaitableObject = require('./WaitableObject.cjs');
+var future = require('../../future/future.cjs');
+var R = require('ramda');
+var synchronize = require('../../synchronize.cjs');
+var stream = require('../../stream.cjs');
+var stream_state = require('../../stream/state.cjs');
+var SimpleQueue = require('./SimpleQueue.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+exports.WatchableObjectOperations = void 0;
+(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";
+})(exports.WatchableObjectOperations || (exports.WatchableObjectOperations = {}));
+class WatchableObject extends WaitableObject.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 synchronize.FutureEvent();
+        const queue = new SimpleQueue.SimpleQueue();
+        const cancelSet = this.onSet((key, oldValue, newValue) => {
+            queue.enqueue({
+                type: exports.WatchableObjectOperations.SET,
+                key,
+                oldValue,
+                newValue,
+            });
+            evt.set();
+        });
+        const cancelDelete = this.onDelete((key, oldValue) => {
+            queue.enqueue({
+                type: exports.WatchableObjectOperations.DELETE,
+                key,
+                oldValue,
+            });
+            evt.set();
+        });
+        const cancelClear = this.onClear(() => {
+            queue.enqueue({
+                type: exports.WatchableObjectOperations.CLEAR,
+                key: "*",
+            });
+            evt.set();
+        });
+        const cleanup = R__namespace.once(() => {
+            cancelClear();
+            cancelSet();
+            cancelDelete();
+        });
+        return new stream.Stream((signal) => _tslib.__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 stream_state.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.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.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.Future.sleep(1)
+                .thenApply(() => this.getListeners.forEach((listener) => listener(key)))
+                .run();
+            callback(v);
+        }, multiCall);
+    }
+    values(copy) {
+        future.Future.sleep(1)
+            .thenApply(() => this.valuesListeners.forEach((listener) => listener()))
+            .run();
+        return super.values(copy);
+    }
+    ingestStream(stream, handler) {
+        return future.Future.of((_, __, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            try {
+                for (var _d = true, stream_1 = _tslib.__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.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();
+    }
+}
+
+exports.WatchableObject = WatchableObject;

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

@@ -0,0 +1,88 @@
+import { WaitableObject } from "./WaitableObject";
+import { Future, WaitPeriod } from "../../future";
+import { Stream } from "../../stream";
+type GetListener<T> = (property: T) => void;
+type SetListener<T, K> = (property: T, oldValue: K | undefined, newValue: K) => void | Promise<void>;
+type DeleteListener<T, K> = (property: T, oldValue: K | undefined) => void;
+export interface WatchableChange<T, K> {
+    type: WatchableObjectOperations.SET | WatchableObjectOperations.CLEAR | WatchableObjectOperations.DELETE;
+    oldValue?: K;
+    newValue?: K;
+    key: T;
+}
+export interface Configuration {
+    entryThreshold: number;
+}
+export declare enum WatchableObjectOperations {
+    DELETE = 0,
+    GET = 1,
+    SET = 2,
+    CLEAR = 3,
+    VALUES = 4
+}
+export declare class WatchableObject<T, K> extends WaitableObject<T, K> {
+    private getListeners;
+    private setListeners;
+    private deleteListeners;
+    private clearListeners;
+    private valuesListeners;
+    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    /**
+     * 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: Stream<K>, keyExtractor: (v: K) => T): Future<void>;
+    clone(): WatchableObject<T, K>;
+    /**
+     * Stream of changes made to the object via SET, DELETE or CLEAR commands
+     */
+    changeStream(): Stream<WatchableChange<T, K>>;
+    /**
+     * Listens whenever a value is retrieved from this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onGet(listener: GetListener<T>): () => void;
+    /**
+     * Listens whenever a property is added or updated on this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onSet(listener: SetListener<T, K>): () => void;
+    /**
+     * Listens whenever a property is deleted from this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onDelete(listener: DeleteListener<T, K>): () => void;
+    /**
+     * Listens whenever this object is wiped clean
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onClear(listener: () => void): () => void;
+    /**
+     * Listens whenever the values() method is invoked on this object
+     * @param listener
+     * @returns unsubscribe function
+     */
+    onValues(listener: () => void): () => void;
+    get(key: T, defaultValue?: K | undefined): K;
+    set(key: T, value: K, expiryPeriod?: WaitPeriod): void;
+    delete(key: T): void;
+    clear(): void;
+    await(key: T, abort?: AbortSignal): Future<K>;
+    on(key: T, callback: (value: K) => void, multiCall?: boolean): () => boolean;
+    values(copy?: boolean): K[];
+    protected ingestStream(stream: Stream<K>, handler: (v: K) => void): Future<void>;
+}
+export {};