gingersnap 0.22.0

package/data-structures/object/Queue.cjs

@@ -0,0 +1,178 @@
+'use strict';
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var WatchableObject = require('./WatchableObject.cjs');
+var FutureCancelled = require('../../errors/FutureCancelled.cjs');
+var QueueEmptyError = require('../../errors/QueueEmptyError.cjs');
+var future = require('../../future/future.cjs');
+require('ramda');
+var synchronize = require('../../synchronize.cjs');
+var stream = require('../../stream.cjs');
+var QueueFullError = require('../../errors/QueueFullError.cjs');
+var ValueDestroyedError = require('../../errors/ValueDestroyedError.cjs');
+
+/**
+ * Queue data structure for First In First Out operation (FIFO)
+ */
+class Queue extends WatchableObject.WatchableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.tail = 0;
+        this.head = 0;
+        this.closedSignal = new AbortController().signal;
+        this.closed = false;
+        this.dequeueEvt = new synchronize.FutureEvent();
+    }
+    get streamEntries() {
+        return stream.Stream.of(this.asyncIterator);
+    }
+    close() {
+        this.closed = true;
+        this.closedSignal.dispatchEvent(new CustomEvent("abort"));
+        this.closedSignal = AbortSignal.abort();
+    }
+    clone() {
+        const obj = super.clone();
+        obj.head = this.head;
+        obj.tail = this.tail;
+        return obj;
+    }
+    ingest(stream) {
+        return this.ingestStream(stream, (data) => this.enqueue(data));
+    }
+    enqueue(value) {
+        if (this.objectMaxSize && this.size() >= this.objectMaxSize) {
+            throw new QueueFullError.QueueFullError();
+        }
+        else if (this.closed) {
+            throw new ValueDestroyedError.ValueDestroyedError();
+        }
+        this.set(this.tail, value);
+        this.tail++;
+    }
+    awaitEnqueue(value) {
+        return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            while (this.objectMaxSize && this.size() >= this.objectMaxSize) {
+                this.dequeueEvt.clear();
+                yield this.dequeueEvt.wait().registerSignal(signal).registerSignal(this.closedSignal);
+            }
+            this.set(this.tail, value);
+            this.tail++;
+            resolve();
+        }));
+    }
+    dequeue() {
+        if (this.closed) {
+            throw new ValueDestroyedError.ValueDestroyedError();
+        }
+        const value = this.get(this.head);
+        if (value !== undefined && value !== null) {
+            this.delete(this.head);
+            this.head++;
+            this.dequeueEvt.set();
+            return value;
+        }
+        throw new QueueEmptyError.QueueEmptyError();
+    }
+    awaitDequeue(abortSignal) {
+        if (this.empty && !this.closed) {
+            return this.await(this.head, abortSignal)
+                .registerSignal(this.closedSignal)
+                .thenApply((v) => {
+                this.delete(this.head);
+                this.head++;
+                this.dequeueEvt.set();
+                return v.value;
+            });
+        }
+        try {
+            return future.Future.completed(this.dequeue());
+        }
+        catch (e) {
+            return future.Future.exceptionally(e);
+        }
+    }
+    awaitEmpty() {
+        return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            while (!this.closed && !this.empty) {
+                this.dequeueEvt.clear();
+                yield this.dequeueEvt.wait();
+            }
+            if (this.closed) {
+                return reject(new ValueDestroyedError.ValueDestroyedError());
+            }
+            resolve();
+        }));
+    }
+    get asyncIterator() {
+        const self = this;
+        const generator = {
+            [Symbol.asyncIterator]() {
+                return generator;
+            },
+            return(value) {
+                return value;
+            },
+            throw(e) {
+                throw e;
+            },
+            next(...args) {
+                return _tslib.__awaiter(this, void 0, void 0, function* () {
+                    try {
+                        return {
+                            done: false,
+                            value: yield self.awaitDequeue(),
+                        };
+                    }
+                    catch (e) {
+                        if (e instanceof ValueDestroyedError.ValueDestroyedError) {
+                            throw new FutureCancelled.FutureCancelled();
+                        }
+                        throw e;
+                    }
+                });
+            },
+        };
+        return generator;
+    }
+    clear() {
+        if (this.closed) {
+            throw new ValueDestroyedError.ValueDestroyedError();
+        }
+        super.clear();
+        this.tail = 0;
+        this.head = 0;
+    }
+    get empty() {
+        return this.tail <= this.head;
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    peek() {
+        if (this.closed) {
+            throw new ValueDestroyedError.ValueDestroyedError();
+        }
+        return this.get(this.head);
+    }
+    next(...args) {
+        if (!this.empty) {
+            return {
+                done: false,
+                value: this.dequeue(),
+            };
+        }
+        return {
+            done: true,
+            value: undefined,
+        };
+    }
+    return(value) {
+        return this.next();
+    }
+    throw(e) {
+        throw e;
+    }
+}
+
+exports.Queue = Queue;

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

@@ -0,0 +1,31 @@
+import { WatchableObject } from "./WatchableObject";
+import { Future, WaitPeriod } from "../../future";
+import { Stream } from "../../stream";
+/**
+ * Queue data structure for First In First Out operation (FIFO)
+ */
+export declare class Queue<T> extends WatchableObject<number, T> implements Iterator<T> {
+    private tail;
+    private head;
+    private closedSignal;
+    private closed;
+    private readonly dequeueEvt;
+    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    get streamEntries(): Stream<T>;
+    close(): void;
+    clone(): Queue<T>;
+    ingest(stream: Stream<T>): Future<void>;
+    enqueue(value: T): void;
+    awaitEnqueue(value: T): Future<void>;
+    dequeue(): T;
+    awaitDequeue(abortSignal?: AbortSignal): Future<T>;
+    awaitEmpty(): Future<void>;
+    get asyncIterator(): AsyncGenerator<T>;
+    clear(): void;
+    get empty(): boolean;
+    size(): number;
+    peek(): T;
+    next(...args: [] | [undefined]): IteratorResult<T, any>;
+    return?(value?: any): IteratorResult<T, any>;
+    throw?(e?: any): IteratorResult<T, any>;
+}

package/data-structures/object/Queue.mjs

@@ -0,0 +1,176 @@
+import { __awaiter } from '../../_virtual/_tslib.mjs';
+import { WatchableObject } from './WatchableObject.mjs';
+import { FutureCancelled } from '../../errors/FutureCancelled.mjs';
+import { QueueEmptyError } from '../../errors/QueueEmptyError.mjs';
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+import { FutureEvent } from '../../synchronize.mjs';
+import { Stream } from '../../stream.mjs';
+import { QueueFullError } from '../../errors/QueueFullError.mjs';
+import { ValueDestroyedError } from '../../errors/ValueDestroyedError.mjs';
+
+/**
+ * Queue data structure for First In First Out operation (FIFO)
+ */
+class Queue extends WatchableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.tail = 0;
+        this.head = 0;
+        this.closedSignal = new AbortController().signal;
+        this.closed = false;
+        this.dequeueEvt = new FutureEvent();
+    }
+    get streamEntries() {
+        return Stream.of(this.asyncIterator);
+    }
+    close() {
+        this.closed = true;
+        this.closedSignal.dispatchEvent(new CustomEvent("abort"));
+        this.closedSignal = AbortSignal.abort();
+    }
+    clone() {
+        const obj = super.clone();
+        obj.head = this.head;
+        obj.tail = this.tail;
+        return obj;
+    }
+    ingest(stream) {
+        return this.ingestStream(stream, (data) => this.enqueue(data));
+    }
+    enqueue(value) {
+        if (this.objectMaxSize && this.size() >= this.objectMaxSize) {
+            throw new QueueFullError();
+        }
+        else if (this.closed) {
+            throw new ValueDestroyedError();
+        }
+        this.set(this.tail, value);
+        this.tail++;
+    }
+    awaitEnqueue(value) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            while (this.objectMaxSize && this.size() >= this.objectMaxSize) {
+                this.dequeueEvt.clear();
+                yield this.dequeueEvt.wait().registerSignal(signal).registerSignal(this.closedSignal);
+            }
+            this.set(this.tail, value);
+            this.tail++;
+            resolve();
+        }));
+    }
+    dequeue() {
+        if (this.closed) {
+            throw new ValueDestroyedError();
+        }
+        const value = this.get(this.head);
+        if (value !== undefined && value !== null) {
+            this.delete(this.head);
+            this.head++;
+            this.dequeueEvt.set();
+            return value;
+        }
+        throw new QueueEmptyError();
+    }
+    awaitDequeue(abortSignal) {
+        if (this.empty && !this.closed) {
+            return this.await(this.head, abortSignal)
+                .registerSignal(this.closedSignal)
+                .thenApply((v) => {
+                this.delete(this.head);
+                this.head++;
+                this.dequeueEvt.set();
+                return v.value;
+            });
+        }
+        try {
+            return Future.completed(this.dequeue());
+        }
+        catch (e) {
+            return Future.exceptionally(e);
+        }
+    }
+    awaitEmpty() {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            while (!this.closed && !this.empty) {
+                this.dequeueEvt.clear();
+                yield this.dequeueEvt.wait();
+            }
+            if (this.closed) {
+                return reject(new ValueDestroyedError());
+            }
+            resolve();
+        }));
+    }
+    get asyncIterator() {
+        const self = this;
+        const generator = {
+            [Symbol.asyncIterator]() {
+                return generator;
+            },
+            return(value) {
+                return value;
+            },
+            throw(e) {
+                throw e;
+            },
+            next(...args) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        return {
+                            done: false,
+                            value: yield self.awaitDequeue(),
+                        };
+                    }
+                    catch (e) {
+                        if (e instanceof ValueDestroyedError) {
+                            throw new FutureCancelled();
+                        }
+                        throw e;
+                    }
+                });
+            },
+        };
+        return generator;
+    }
+    clear() {
+        if (this.closed) {
+            throw new ValueDestroyedError();
+        }
+        super.clear();
+        this.tail = 0;
+        this.head = 0;
+    }
+    get empty() {
+        return this.tail <= this.head;
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    peek() {
+        if (this.closed) {
+            throw new ValueDestroyedError();
+        }
+        return this.get(this.head);
+    }
+    next(...args) {
+        if (!this.empty) {
+            return {
+                done: false,
+                value: this.dequeue(),
+            };
+        }
+        return {
+            done: true,
+            value: undefined,
+        };
+    }
+    return(value) {
+        return this.next();
+    }
+    throw(e) {
+        throw e;
+    }
+}
+
+export { Queue };

package/data-structures/object/SimpleQueue.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+var QueueEmptyError = require('../../errors/QueueEmptyError.cjs');
+
+class SimpleQueue {
+    constructor() {
+        this.items = new Map();
+        this.head = 0;
+        this.tail = 0;
+    }
+    enqueue(element) {
+        this.items.set(this.tail, element);
+        this.tail++;
+    }
+    forEach(callback) {
+        while (!this.empty) {
+            const result = this.dequeue();
+            if (result === undefined)
+                return;
+            callback(result);
+        }
+    }
+    dequeue() {
+        if (this.empty) {
+            throw new QueueEmptyError.QueueEmptyError();
+        }
+        const item = this.items.get(this.head);
+        this.items.delete(this.head);
+        this.head++;
+        return item;
+    }
+    peek() {
+        if (this.empty) {
+            throw new QueueEmptyError.QueueEmptyError();
+        }
+        return this.items.get(this.head);
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    get empty() {
+        return this.size() === 0;
+    }
+    clone() {
+        const obj = new SimpleQueue();
+        obj.items = new Map(this.items);
+        obj.tail = this.tail;
+        obj.head = this.head;
+        return obj;
+    }
+}
+
+exports.SimpleQueue = SimpleQueue;

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

@@ -0,0 +1,13 @@
+export declare class SimpleQueue<T> {
+    private items;
+    private head;
+    private tail;
+    constructor();
+    enqueue(element: T): void;
+    forEach(callback: (v: T) => void): void;
+    dequeue(): T;
+    peek(): T;
+    size(): number;
+    get empty(): boolean;
+    clone(): SimpleQueue<T>;
+}

package/data-structures/object/SimpleQueue.mjs

@@ -0,0 +1,51 @@
+import { QueueEmptyError } from '../../errors/QueueEmptyError.mjs';
+
+class SimpleQueue {
+    constructor() {
+        this.items = new Map();
+        this.head = 0;
+        this.tail = 0;
+    }
+    enqueue(element) {
+        this.items.set(this.tail, element);
+        this.tail++;
+    }
+    forEach(callback) {
+        while (!this.empty) {
+            const result = this.dequeue();
+            if (result === undefined)
+                return;
+            callback(result);
+        }
+    }
+    dequeue() {
+        if (this.empty) {
+            throw new QueueEmptyError();
+        }
+        const item = this.items.get(this.head);
+        this.items.delete(this.head);
+        this.head++;
+        return item;
+    }
+    peek() {
+        if (this.empty) {
+            throw new QueueEmptyError();
+        }
+        return this.items.get(this.head);
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    get empty() {
+        return this.size() === 0;
+    }
+    clone() {
+        const obj = new SimpleQueue();
+        obj.items = new Map(this.items);
+        obj.tail = this.tail;
+        obj.head = this.head;
+        return obj;
+    }
+}
+
+export { SimpleQueue };

package/data-structures/object/TimeableObject.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var hash = require('object-hash');
+var CyclicalObject = require('./CyclicalObject.cjs');
+var future = require('../../future/future.cjs');
+require('ramda');
+require('../../stream.cjs');
+
+/**
+ * Object that has key value pairs that can expire
+ */
+class TimeableObject extends CyclicalObject.CyclicalObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize);
+        this.timers = new Map();
+        this.expiryPeriod = expiryPeriod;
+    }
+    /**
+     * Sets the value for the given key
+     * @param key
+     * @param value dat to be stored
+     * @param expiryPeriod When should this value expire
+     */
+    set(key, value, expiryPeriod) {
+        var _a;
+        const hashedKey = this.computeHash(key);
+        const timer = this.timers.get(hashedKey);
+        timer === null || timer === void 0 ? void 0 : timer.cancel();
+        super.set(key, value);
+        if (expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) {
+            this.timers.set(hashedKey, future.Future.sleep((_a = expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+                .thenApply(() => this.delete(key))
+                .schedule());
+        }
+    }
+    get(key, defaultValue = undefined) {
+        var _a;
+        const result = super.get(key, defaultValue);
+        if (result !== undefined) {
+            if (this.expiryPeriod) {
+                const hashedKey = this.computeHash(key);
+                const timer = this.timers.get(hashedKey);
+                timer === null || timer === void 0 ? void 0 : timer.cancel();
+                this.timers.set(hashedKey, future.Future.sleep((_a = this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+                    .thenApply(() => this.delete(key))
+                    .schedule());
+            }
+        }
+        return result;
+    }
+    delete(key) {
+        const hashedKey = this.computeHash(key);
+        const timer = this.timers.get(hashedKey);
+        timer === null || timer === void 0 ? void 0 : timer.cancel();
+        this.timers.delete(hashedKey);
+        super.delete(key);
+    }
+    clear() {
+        this.timers.forEach((future) => future.cancel());
+        this.timers.clear();
+        super.clear();
+    }
+    clone() {
+        const obj = super.clone();
+        obj.expiryPeriod = this.expiryPeriod;
+        return obj;
+    }
+    computeHash(key) {
+        return typeof key === "string" ? key : hash.sha1(String(key));
+    }
+}
+
+exports.TimeableObject = TimeableObject;

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

@@ -0,0 +1,30 @@
+import { CyclicalObject } from "./CyclicalObject";
+import { WaitPeriod } from "../../future";
+/**
+ * Object that has key value pairs that can expire
+ */
+export declare class TimeableObject<T, K> extends CyclicalObject<T, K> {
+    /**
+     * default expiration time for each added key value pair
+     * @private
+     */
+    protected expiryPeriod?: WaitPeriod;
+    /**
+     * mapping of timings for each key value pair
+     * @private
+     */
+    private readonly timers;
+    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    /**
+     * Sets the value for the given key
+     * @param key
+     * @param value dat to be stored
+     * @param expiryPeriod When should this value expire
+     */
+    set(key: T, value: K, expiryPeriod?: WaitPeriod): void;
+    get(key: T, defaultValue?: K | undefined): K | undefined;
+    delete(key: T): void;
+    clear(): void;
+    clone(): TimeableObject<T, K>;
+    protected computeHash(key: T): string;
+}

package/data-structures/object/TimeableObject.mjs

@@ -0,0 +1,71 @@
+import hash from 'object-hash';
+import { CyclicalObject } from './CyclicalObject.mjs';
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+import '../../stream.mjs';
+
+/**
+ * Object that has key value pairs that can expire
+ */
+class TimeableObject extends CyclicalObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize);
+        this.timers = new Map();
+        this.expiryPeriod = expiryPeriod;
+    }
+    /**
+     * Sets the value for the given key
+     * @param key
+     * @param value dat to be stored
+     * @param expiryPeriod When should this value expire
+     */
+    set(key, value, expiryPeriod) {
+        var _a;
+        const hashedKey = this.computeHash(key);
+        const timer = this.timers.get(hashedKey);
+        timer === null || timer === void 0 ? void 0 : timer.cancel();
+        super.set(key, value);
+        if (expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) {
+            this.timers.set(hashedKey, Future.sleep((_a = expiryPeriod !== null && expiryPeriod !== void 0 ? expiryPeriod : this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+                .thenApply(() => this.delete(key))
+                .schedule());
+        }
+    }
+    get(key, defaultValue = undefined) {
+        var _a;
+        const result = super.get(key, defaultValue);
+        if (result !== undefined) {
+            if (this.expiryPeriod) {
+                const hashedKey = this.computeHash(key);
+                const timer = this.timers.get(hashedKey);
+                timer === null || timer === void 0 ? void 0 : timer.cancel();
+                this.timers.set(hashedKey, Future.sleep((_a = this.expiryPeriod) !== null && _a !== void 0 ? _a : 0)
+                    .thenApply(() => this.delete(key))
+                    .schedule());
+            }
+        }
+        return result;
+    }
+    delete(key) {
+        const hashedKey = this.computeHash(key);
+        const timer = this.timers.get(hashedKey);
+        timer === null || timer === void 0 ? void 0 : timer.cancel();
+        this.timers.delete(hashedKey);
+        super.delete(key);
+    }
+    clear() {
+        this.timers.forEach((future) => future.cancel());
+        this.timers.clear();
+        super.clear();
+    }
+    clone() {
+        const obj = super.clone();
+        obj.expiryPeriod = this.expiryPeriod;
+        return obj;
+    }
+    computeHash(key) {
+        return typeof key === "string" ? key : hash.sha1(String(key));
+    }
+}
+
+export { TimeableObject };