gingersnap 0.22.0

package/data-structures/object/BufferQueue.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+var WatchableObject = require('./WatchableObject.cjs');
+var TimeableObject = require('./TimeableObject.cjs');
+var R = require('ramda');
+var stream = require('../../stream.cjs');
+var stream_state = require('../../stream/state.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);
+
+/**
+ * Queue data structure that is iterable, but never can dequeue
+ */
+class BufferQueue extends WatchableObject.WatchableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.tail = 0;
+        this.head = 0;
+        this.tracker = new TimeableObject.TimeableObject(objectMaxSize, expiryPeriod);
+    }
+    ingest(stream) {
+        return this.ingestStream(stream, (data) => this.enqueue(data));
+    }
+    streamEntries(ignoreCache = false) {
+        let pointer = ignoreCache ? this.tail : 0;
+        return new stream.Stream(((signal) => {
+            const value = this.get(pointer);
+            if (value !== undefined) {
+                pointer++;
+                return value;
+            }
+            return new Promise((resolve) => {
+                const unsubscribe = this.on(pointer, (v) => {
+                    pointer++;
+                    resolve(v);
+                }, false);
+                signal.onabort = () => {
+                    unsubscribe();
+                    resolve(new stream_state.ExecutorState(true));
+                };
+            });
+        }));
+    }
+    clone() {
+        const obj = super.clone();
+        obj.head = this.head;
+        obj.tail = this.tail;
+        obj.tracker = this.tracker;
+        return obj;
+    }
+    enqueue(value, tracker) {
+        this.set(this.tail, value);
+        if (!R__namespace.isNil(tracker)) {
+            this.tracker.set(tracker, this.tail);
+        }
+        this.tail++;
+        if (!this.has(this.head)) {
+            this.head++;
+        }
+    }
+    clear() {
+        super.clear();
+        this.tail = 0;
+        this.head = 0;
+        this.tracker.clear();
+    }
+    get empty() {
+        return this.tail <= this.head;
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    peek(index) {
+        return this.get(index !== null && index !== void 0 ? index : this.head);
+    }
+    findIndex(tracker) {
+        return this.tracker.get(tracker);
+    }
+}
+
+exports.BufferQueue = BufferQueue;

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

@@ -0,0 +1,21 @@
+import { WatchableObject } from "./WatchableObject";
+import { Future, WaitPeriod } from "../../future";
+import { Stream } from "../../stream";
+/**
+ * Queue data structure that is iterable, but never can dequeue
+ */
+export declare class BufferQueue<T> extends WatchableObject<number, T> {
+    private tail;
+    private head;
+    private readonly tracker;
+    constructor(objectMaxSize?: number, expiryPeriod?: WaitPeriod);
+    ingest(stream: Stream<T>): Future<void>;
+    streamEntries(ignoreCache?: boolean): Stream<T>;
+    clone(): BufferQueue<T>;
+    enqueue(value: T, tracker?: string | number): void;
+    clear(): void;
+    get empty(): boolean;
+    size(): number;
+    peek(index?: number): T;
+    findIndex(tracker: string | number): number;
+}

package/data-structures/object/BufferQueue.mjs

@@ -0,0 +1,77 @@
+import { WatchableObject } from './WatchableObject.mjs';
+import { TimeableObject } from './TimeableObject.mjs';
+import * as R from 'ramda';
+import { Stream } from '../../stream.mjs';
+import { ExecutorState } from '../../stream/state.mjs';
+
+/**
+ * Queue data structure that is iterable, but never can dequeue
+ */
+class BufferQueue extends WatchableObject {
+    constructor(objectMaxSize, expiryPeriod) {
+        super(objectMaxSize, expiryPeriod);
+        this.tail = 0;
+        this.head = 0;
+        this.tracker = new TimeableObject(objectMaxSize, expiryPeriod);
+    }
+    ingest(stream) {
+        return this.ingestStream(stream, (data) => this.enqueue(data));
+    }
+    streamEntries(ignoreCache = false) {
+        let pointer = ignoreCache ? this.tail : 0;
+        return new Stream(((signal) => {
+            const value = this.get(pointer);
+            if (value !== undefined) {
+                pointer++;
+                return value;
+            }
+            return new Promise((resolve) => {
+                const unsubscribe = this.on(pointer, (v) => {
+                    pointer++;
+                    resolve(v);
+                }, false);
+                signal.onabort = () => {
+                    unsubscribe();
+                    resolve(new ExecutorState(true));
+                };
+            });
+        }));
+    }
+    clone() {
+        const obj = super.clone();
+        obj.head = this.head;
+        obj.tail = this.tail;
+        obj.tracker = this.tracker;
+        return obj;
+    }
+    enqueue(value, tracker) {
+        this.set(this.tail, value);
+        if (!R.isNil(tracker)) {
+            this.tracker.set(tracker, this.tail);
+        }
+        this.tail++;
+        if (!this.has(this.head)) {
+            this.head++;
+        }
+    }
+    clear() {
+        super.clear();
+        this.tail = 0;
+        this.head = 0;
+        this.tracker.clear();
+    }
+    get empty() {
+        return this.tail <= this.head;
+    }
+    size() {
+        return this.tail - this.head;
+    }
+    peek(index) {
+        return this.get(index !== null && index !== void 0 ? index : this.head);
+    }
+    findIndex(tracker) {
+        return this.tracker.get(tracker);
+    }
+}
+
+export { BufferQueue };

package/data-structures/object/CyclicalObject.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+var R = require('ramda');
+var stream = require('../../stream.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);
+
+/**
+ * Object that is cyclical - has can store M keys, after which new key value pairs added override
+ * previous entries.
+ */
+class CyclicalObject {
+    constructor(objectMaxSize) {
+        this.target = [];
+        this.keyMapping = new Map();
+        this.pointer = -1;
+        this.objectMaxSize = objectMaxSize;
+        this.emptySlots = [];
+    }
+    static from(data) {
+        const obj = new this();
+        if (data instanceof Map) {
+            for (const [k, v] of data.entries()) {
+                obj.set(k, v);
+            }
+        }
+        else if (data instanceof Array || Array.isArray(data)) {
+            for (const [k, v] of data) {
+                obj.set(k, v);
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(data)) {
+                obj.set(k, v);
+            }
+        }
+        return obj;
+    }
+    get stream() {
+        return stream.Stream.of(this.target[Symbol.iterator]());
+    }
+    /**
+     * Retrieves the value associated with the given key. If not exist, the default response will be returned
+     * @param key
+     * @param defaultValue
+     */
+    get(key, defaultValue = undefined) {
+        const index = this.keyMapping.get(key);
+        return !R__namespace.isNil(index) ? this.target[index] : defaultValue;
+    }
+    /**
+     * Add the given key value pair to the object. This will overwrite any existing entry that has the same key
+     * @param key
+     * @param value
+     */
+    set(key, value) {
+        if (this.objectMaxSize) {
+            const index = this.keyMapping.get(key);
+            if (!R__namespace.isNil(index)) {
+                this.target[index] = value;
+                return;
+            }
+            else if (this.emptySlots.length) {
+                const index = this.emptySlots.pop();
+                this.target[index] = value;
+                return;
+            }
+            this.pointer = this.objectMaxSize ? (this.pointer + 1) % this.objectMaxSize : this.pointer + 1;
+            this.target[this.pointer] = value;
+            this.keyMapping.set(key, this.pointer);
+            return;
+        }
+        this.target.push(value);
+        this.keyMapping.set(key, this.target.length - 1);
+    }
+    /**
+     * Removes the value associated with the given key if it exists
+     * @param key
+     */
+    delete(key) {
+        const index = this.keyMapping.get(key);
+        if (!R__namespace.isNil(index)) {
+            this.emptySlots.push(index);
+            this.target[index] = undefined;
+        }
+    }
+    /**
+     * Checks if the object has the given key
+     * @param key
+     */
+    has(key) {
+        return this.keyMapping.has(key);
+    }
+    /**
+     * Iterates over each entry in the object by executing the provided callback on each entry
+     * @param callback
+     */
+    forEach(callback) {
+        Array.from(this.keyMapping.entries()).forEach(([key, index]) => callback(this.target[index], key));
+    }
+    /**
+     * Wipes all key value pairs
+     */
+    clear() {
+        this.pointer = -1;
+        this.target = this.objectMaxSize ? new Array(this.objectMaxSize) : [];
+        this.keyMapping.clear();
+    }
+    /**
+     * Retrieves all the values from this object
+     * @param copy Used to create a copied view of the values
+     */
+    values(copy) {
+        return copy ? R__namespace.clone(this.target.filter((v) => v !== undefined)) : this.target.filter((v) => v !== undefined);
+    }
+    /**
+     * Retrieves the keys that are stored in this object
+     */
+    keys() {
+        return this.keyMapping.keys();
+    }
+    /**
+     * Retrieves the object size
+     */
+    size() {
+        return this.pointer > -1 ? this.pointer + 1 : this.keyMapping.size;
+    }
+    clone() {
+        const obj = new (Object.getPrototypeOf(this).constructor)();
+        obj.target = R__namespace.clone(this.target);
+        obj.pointer = this.pointer;
+        obj.objectMaxSize = this.objectMaxSize;
+        obj.keyMapping = R__namespace.clone(this.keyMapping);
+        return obj;
+    }
+}
+
+exports.CyclicalObject = CyclicalObject;

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

@@ -0,0 +1,74 @@
+import { Stream } from "../../stream";
+/**
+ * Object that is cyclical - has can store M keys, after which new key value pairs added override
+ * previous entries.
+ */
+export declare class CyclicalObject<T, K> {
+    /**
+     * Underlying javascript data structure
+     * @private
+     */
+    private target;
+    private readonly keyMapping;
+    /**
+     * Pointer to the current index
+     * @private
+     */
+    private pointer;
+    /**
+     * Maximum size of this object
+     * @private
+     */
+    protected readonly objectMaxSize?: number;
+    private readonly emptySlots;
+    constructor(objectMaxSize?: number);
+    static from<T, K>(data: Map<T, K> | Array<[T, K]> | {
+        T: K;
+    }): CyclicalObject<T, K>;
+    get stream(): Stream<K>;
+    /**
+     * Retrieves the value associated with the given key. If not exist, the default response will be returned
+     * @param key
+     * @param defaultValue
+     */
+    get(key: T, defaultValue?: K | undefined): K;
+    /**
+     * Add the given key value pair to the object. This will overwrite any existing entry that has the same key
+     * @param key
+     * @param value
+     */
+    set(key: T, value: K): void;
+    /**
+     * Removes the value associated with the given key if it exists
+     * @param key
+     */
+    delete(key: T): void;
+    /**
+     * Checks if the object has the given key
+     * @param key
+     */
+    has(key: T): boolean;
+    /**
+     * Iterates over each entry in the object by executing the provided callback on each entry
+     * @param callback
+     */
+    forEach(callback: (value: K, key: T) => void): void;
+    /**
+     * Wipes all key value pairs
+     */
+    clear(): void;
+    /**
+     * Retrieves all the values from this object
+     * @param copy Used to create a copied view of the values
+     */
+    values(copy?: boolean): K[];
+    /**
+     * Retrieves the keys that are stored in this object
+     */
+    keys(): IterableIterator<T>;
+    /**
+     * Retrieves the object size
+     */
+    size(): number;
+    clone(): CyclicalObject<T, K>;
+}

package/data-structures/object/CyclicalObject.mjs

@@ -0,0 +1,134 @@
+import * as R from 'ramda';
+import { Stream } from '../../stream.mjs';
+
+/**
+ * Object that is cyclical - has can store M keys, after which new key value pairs added override
+ * previous entries.
+ */
+class CyclicalObject {
+    constructor(objectMaxSize) {
+        this.target = [];
+        this.keyMapping = new Map();
+        this.pointer = -1;
+        this.objectMaxSize = objectMaxSize;
+        this.emptySlots = [];
+    }
+    static from(data) {
+        const obj = new this();
+        if (data instanceof Map) {
+            for (const [k, v] of data.entries()) {
+                obj.set(k, v);
+            }
+        }
+        else if (data instanceof Array || Array.isArray(data)) {
+            for (const [k, v] of data) {
+                obj.set(k, v);
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(data)) {
+                obj.set(k, v);
+            }
+        }
+        return obj;
+    }
+    get stream() {
+        return Stream.of(this.target[Symbol.iterator]());
+    }
+    /**
+     * Retrieves the value associated with the given key. If not exist, the default response will be returned
+     * @param key
+     * @param defaultValue
+     */
+    get(key, defaultValue = undefined) {
+        const index = this.keyMapping.get(key);
+        return !R.isNil(index) ? this.target[index] : defaultValue;
+    }
+    /**
+     * Add the given key value pair to the object. This will overwrite any existing entry that has the same key
+     * @param key
+     * @param value
+     */
+    set(key, value) {
+        if (this.objectMaxSize) {
+            const index = this.keyMapping.get(key);
+            if (!R.isNil(index)) {
+                this.target[index] = value;
+                return;
+            }
+            else if (this.emptySlots.length) {
+                const index = this.emptySlots.pop();
+                this.target[index] = value;
+                return;
+            }
+            this.pointer = this.objectMaxSize ? (this.pointer + 1) % this.objectMaxSize : this.pointer + 1;
+            this.target[this.pointer] = value;
+            this.keyMapping.set(key, this.pointer);
+            return;
+        }
+        this.target.push(value);
+        this.keyMapping.set(key, this.target.length - 1);
+    }
+    /**
+     * Removes the value associated with the given key if it exists
+     * @param key
+     */
+    delete(key) {
+        const index = this.keyMapping.get(key);
+        if (!R.isNil(index)) {
+            this.emptySlots.push(index);
+            this.target[index] = undefined;
+        }
+    }
+    /**
+     * Checks if the object has the given key
+     * @param key
+     */
+    has(key) {
+        return this.keyMapping.has(key);
+    }
+    /**
+     * Iterates over each entry in the object by executing the provided callback on each entry
+     * @param callback
+     */
+    forEach(callback) {
+        Array.from(this.keyMapping.entries()).forEach(([key, index]) => callback(this.target[index], key));
+    }
+    /**
+     * Wipes all key value pairs
+     */
+    clear() {
+        this.pointer = -1;
+        this.target = this.objectMaxSize ? new Array(this.objectMaxSize) : [];
+        this.keyMapping.clear();
+    }
+    /**
+     * Retrieves all the values from this object
+     * @param copy Used to create a copied view of the values
+     */
+    values(copy) {
+        return copy ? R.clone(this.target.filter((v) => v !== undefined)) : this.target.filter((v) => v !== undefined);
+    }
+    /**
+     * Retrieves the keys that are stored in this object
+     */
+    keys() {
+        return this.keyMapping.keys();
+    }
+    /**
+     * Retrieves the object size
+     */
+    size() {
+        return this.pointer > -1 ? this.pointer + 1 : this.keyMapping.size;
+    }
+    clone() {
+        const obj = new (Object.getPrototypeOf(this).constructor)();
+        obj.target = R.clone(this.target);
+        obj.pointer = this.pointer;
+        obj.objectMaxSize = this.objectMaxSize;
+        obj.keyMapping = R.clone(this.keyMapping);
+        return obj;
+    }
+}
+
+export { CyclicalObject };