gingersnap 0.22.0

package/data/value.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var future = require('../future/future.cjs');
+require('ramda');
+var synchronize = require('../synchronize.cjs');
+var stream = require('../stream.cjs');
+var stream_state = require('../stream/state.cjs');
+var ValueDestroyedError = require('../errors/ValueDestroyedError.cjs');
+
+class AtomicValue {
+    constructor() {
+        this.setEvt = new synchronize.FutureEvent();
+        this.setLock = new synchronize.Lock();
+        this.closed = false;
+    }
+    set(value) {
+        return this.setLock.with(() => _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                throw new ValueDestroyedError.ValueDestroyedError();
+            }
+            this.value = value;
+            this.setEvt.set();
+        }));
+    }
+    get() {
+        return this.read(false);
+    }
+    pop() {
+        return this.read(true);
+    }
+    destroy() {
+        this.closed = true;
+    }
+    get stream() {
+        return new stream.Stream((signal) => this.pop()
+            .catch((error) => {
+            if (error instanceof ValueDestroyedError.ValueDestroyedError) {
+                return new stream_state.ExecutorState(true);
+            }
+            throw error;
+        })
+            .registerSignal(signal));
+    }
+    read(removeValue) {
+        return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            while (this.value === undefined && !this.closed) {
+                this.setEvt.clear();
+                yield this.setEvt.wait().registerSignal(signal);
+            }
+            if (this.closed && this.value === undefined) {
+                return reject(new ValueDestroyedError.ValueDestroyedError());
+            }
+            const value = this.value;
+            if (removeValue) {
+                this.value = undefined;
+            }
+            resolve(value);
+            if (this.closed) {
+                return reject(new ValueDestroyedError.ValueDestroyedError());
+            }
+        }));
+    }
+}
+
+exports.AtomicValue = AtomicValue;

package/data/value.mjs

@@ -0,0 +1,64 @@
+import { __awaiter } from '../_virtual/_tslib.mjs';
+import { Future } from '../future/future.mjs';
+import 'ramda';
+import { FutureEvent, Lock } from '../synchronize.mjs';
+import { Stream } from '../stream.mjs';
+import { ExecutorState } from '../stream/state.mjs';
+import { ValueDestroyedError } from '../errors/ValueDestroyedError.mjs';
+
+class AtomicValue {
+    constructor() {
+        this.setEvt = new FutureEvent();
+        this.setLock = new Lock();
+        this.closed = false;
+    }
+    set(value) {
+        return this.setLock.with(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                throw new ValueDestroyedError();
+            }
+            this.value = value;
+            this.setEvt.set();
+        }));
+    }
+    get() {
+        return this.read(false);
+    }
+    pop() {
+        return this.read(true);
+    }
+    destroy() {
+        this.closed = true;
+    }
+    get stream() {
+        return new Stream((signal) => this.pop()
+            .catch((error) => {
+            if (error instanceof ValueDestroyedError) {
+                return new ExecutorState(true);
+            }
+            throw error;
+        })
+            .registerSignal(signal));
+    }
+    read(removeValue) {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            while (this.value === undefined && !this.closed) {
+                this.setEvt.clear();
+                yield this.setEvt.wait().registerSignal(signal);
+            }
+            if (this.closed && this.value === undefined) {
+                return reject(new ValueDestroyedError());
+            }
+            const value = this.value;
+            if (removeValue) {
+                this.value = undefined;
+            }
+            resolve(value);
+            if (this.closed) {
+                return reject(new ValueDestroyedError());
+            }
+        }));
+    }
+}
+
+export { AtomicValue };

package/data-structures/array/CyclicalList.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var stream = require('../../stream.cjs');
+
+class CyclicalList extends Array {
+    constructor(maxSize) {
+        super();
+        this.pointer = this.length - 1;
+        this.maxSize = maxSize;
+        if (maxSize) {
+            this.push = (...items) => {
+                for (const item of items) {
+                    this.pointer = (this.pointer + 1) % maxSize;
+                    this[this.pointer] = item;
+                }
+                return this.pointer < maxSize ? this.pointer : maxSize;
+            };
+            this.pop = () => {
+                this.pointer--;
+                if (this.pointer < -1) {
+                    this.pointer = -1;
+                }
+                return super.pop();
+            };
+            this.shift = () => {
+                this.pointer--;
+                if (this.pointer < -1) {
+                    this.pointer = -1;
+                }
+                return super.shift();
+            };
+            this.unshift = (...items) => {
+                for (let i = items.length - 1; i >= 0; i--) {
+                    const item = items[i];
+                    if (this.length >= maxSize) {
+                        this.pop();
+                    }
+                    this.pointer++;
+                    this.unshift(item);
+                }
+                return this.length;
+            };
+        }
+    }
+    static from(items) {
+        const list = new this(items.length);
+        for (const item of items) {
+            list.push(item);
+        }
+        return list;
+    }
+    get stream() {
+        return stream.Stream.of(this);
+    }
+}
+
+exports.CyclicalList = CyclicalList;

package/data-structures/array/CyclicalList.d.ts

@@ -0,0 +1,12 @@
+import { Stream } from "../../stream";
+export declare class CyclicalList<T> extends Array<T> {
+    /**
+     * Pointer to the current index
+     * @private
+     */
+    protected pointer: number;
+    protected readonly maxSize?: number;
+    constructor(maxSize?: number);
+    static from<T>(items: T[]): CyclicalList<T>;
+    get stream(): Stream<T>;
+}

package/data-structures/array/CyclicalList.mjs

@@ -0,0 +1,55 @@
+import { Stream } from '../../stream.mjs';
+
+class CyclicalList extends Array {
+    constructor(maxSize) {
+        super();
+        this.pointer = this.length - 1;
+        this.maxSize = maxSize;
+        if (maxSize) {
+            this.push = (...items) => {
+                for (const item of items) {
+                    this.pointer = (this.pointer + 1) % maxSize;
+                    this[this.pointer] = item;
+                }
+                return this.pointer < maxSize ? this.pointer : maxSize;
+            };
+            this.pop = () => {
+                this.pointer--;
+                if (this.pointer < -1) {
+                    this.pointer = -1;
+                }
+                return super.pop();
+            };
+            this.shift = () => {
+                this.pointer--;
+                if (this.pointer < -1) {
+                    this.pointer = -1;
+                }
+                return super.shift();
+            };
+            this.unshift = (...items) => {
+                for (let i = items.length - 1; i >= 0; i--) {
+                    const item = items[i];
+                    if (this.length >= maxSize) {
+                        this.pop();
+                    }
+                    this.pointer++;
+                    this.unshift(item);
+                }
+                return this.length;
+            };
+        }
+    }
+    static from(items) {
+        const list = new this(items.length);
+        for (const item of items) {
+            list.push(item);
+        }
+        return list;
+    }
+    get stream() {
+        return Stream.of(this);
+    }
+}
+
+export { CyclicalList };

package/data-structures/array/Pair.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * An immutable tuple of 2 values
+ */
+class Pair {
+    constructor(_first, _second) {
+        this._first = _first;
+        this._second = _second;
+    }
+    get first() {
+        return this._first;
+    }
+    get second() {
+        return this._second;
+    }
+    get last() {
+        return this.second;
+    }
+    get values() {
+        return [this._first, this._second];
+    }
+}
+/**
+ * Creates an immutable tuple of 2 values
+ */
+const pair = (first, second) => new Pair(first, second);
+
+exports.Pair = Pair;
+exports.pair = pair;

package/data-structures/array/Pair.d.ts

@@ -0,0 +1,17 @@
+import { Tuple } from "./Tuple";
+/**
+ * An immutable tuple of 2 values
+ */
+export declare class Pair<T, V> implements Tuple<T, V> {
+    private readonly _first;
+    private readonly _second;
+    constructor(_first: T, _second: V);
+    get first(): T;
+    get second(): V;
+    get last(): V;
+    get values(): [T, V];
+}
+/**
+ * Creates an immutable tuple of 2 values
+ */
+export declare const pair: <T, V>(first: T, second: V) => Pair<T, V>;

package/data-structures/array/Pair.mjs

@@ -0,0 +1,27 @@
+/**
+ * An immutable tuple of 2 values
+ */
+class Pair {
+    constructor(_first, _second) {
+        this._first = _first;
+        this._second = _second;
+    }
+    get first() {
+        return this._first;
+    }
+    get second() {
+        return this._second;
+    }
+    get last() {
+        return this.second;
+    }
+    get values() {
+        return [this._first, this._second];
+    }
+}
+/**
+ * Creates an immutable tuple of 2 values
+ */
+const pair = (first, second) => new Pair(first, second);
+
+export { Pair, pair };

package/data-structures/array/Stack.cjs

@@ -0,0 +1,96 @@
+'use strict';
+
+var CyclicalList = require('./CyclicalList.cjs');
+var NotImplemented = require('../../errors/NotImplemented.cjs');
+var StackEmptyError = require('../../errors/StackEmptyError.cjs');
+var StackFullError = require('../../errors/StackFullError.cjs');
+var synchronize = require('../../synchronize.cjs');
+var stream = require('../../stream.cjs');
+var future = require('../../future/future.cjs');
+require('ramda');
+
+/**
+ * Stack data structure for Last In First Out operation (LIFO)
+ */
+class Stack extends CyclicalList.CyclicalList {
+    constructor(maxSize) {
+        super(maxSize);
+        this.totalEntries = 0;
+        this.evt = new synchronize.FutureEvent();
+    }
+    unshift(...items) {
+        throw new NotImplemented.NotImplemented();
+    }
+    shift() {
+        throw new NotImplemented.NotImplemented();
+    }
+    get stream() {
+        return new stream.Stream((v) => this.awaitPop(v));
+    }
+    push(...items) {
+        this.evt.set();
+        this.totalEntries++;
+        if (this.maxSize && this.totalEntries > this.maxSize) {
+            throw new StackFullError.StackFullError();
+        }
+        return super.push(...items);
+    }
+    pop() {
+        if (this.length === 0)
+            throw new StackEmptyError.StackEmptyError();
+        this.evt.clear();
+        this.totalEntries--;
+        return super.pop();
+    }
+    /**
+     * Awaits a value being available on the stack to retrieve it
+     * @param abortSignal
+     */
+    awaitPop(abortSignal) {
+        if (this.size() === 0) {
+            const future = this.evt.wait();
+            if (abortSignal)
+                future.registerSignal(abortSignal);
+            return future.then((v) => {
+                if (this.size() > 0)
+                    return this.pop();
+                return this.awaitPop(v.signal);
+            });
+        }
+        return future.Future.completed(this.pop());
+    }
+    /**
+     * Retrieves the last item added to the stack
+     */
+    peek() {
+        return this[this.pointer];
+    }
+    /**
+     * Checks if the stack is empty
+     */
+    get empty() {
+        return this.totalEntries === 0;
+    }
+    /**
+     * Checks if the stack is full
+     */
+    get full() {
+        return this.size() === this.maxSize;
+    }
+    /**
+     * Retrieves the current stack size
+     */
+    size() {
+        return this.totalEntries;
+    }
+    /**
+     * Empty the stack
+     */
+    clear() {
+        while (!this.empty) {
+            this.pop();
+        }
+    }
+}
+
+exports.Stack = Stack;

package/data-structures/array/Stack.d.ts

@@ -0,0 +1,41 @@
+import { CyclicalList } from "./CyclicalList";
+import { Stream } from "../../stream";
+import { Future } from "../../future";
+/**
+ * Stack data structure for Last In First Out operation (LIFO)
+ */
+export declare class Stack<T> extends CyclicalList<T> {
+    private readonly evt;
+    private totalEntries;
+    constructor(maxSize?: number);
+    unshift(...items: any[]): number;
+    shift(): T | undefined;
+    get stream(): Stream<T>;
+    push(...items: any[]): number;
+    pop(): T;
+    /**
+     * Awaits a value being available on the stack to retrieve it
+     * @param abortSignal
+     */
+    awaitPop(abortSignal?: AbortSignal): Future<T>;
+    /**
+     * Retrieves the last item added to the stack
+     */
+    peek(): T;
+    /**
+     * Checks if the stack is empty
+     */
+    get empty(): boolean;
+    /**
+     * Checks if the stack is full
+     */
+    get full(): boolean;
+    /**
+     * Retrieves the current stack size
+     */
+    size(): number;
+    /**
+     * Empty the stack
+     */
+    clear(): void;
+}

package/data-structures/array/Stack.mjs

@@ -0,0 +1,94 @@
+import { CyclicalList } from './CyclicalList.mjs';
+import { NotImplemented } from '../../errors/NotImplemented.mjs';
+import { StackEmptyError } from '../../errors/StackEmptyError.mjs';
+import { StackFullError } from '../../errors/StackFullError.mjs';
+import { FutureEvent } from '../../synchronize.mjs';
+import { Stream } from '../../stream.mjs';
+import { Future } from '../../future/future.mjs';
+import 'ramda';
+
+/**
+ * Stack data structure for Last In First Out operation (LIFO)
+ */
+class Stack extends CyclicalList {
+    constructor(maxSize) {
+        super(maxSize);
+        this.totalEntries = 0;
+        this.evt = new FutureEvent();
+    }
+    unshift(...items) {
+        throw new NotImplemented();
+    }
+    shift() {
+        throw new NotImplemented();
+    }
+    get stream() {
+        return new Stream((v) => this.awaitPop(v));
+    }
+    push(...items) {
+        this.evt.set();
+        this.totalEntries++;
+        if (this.maxSize && this.totalEntries > this.maxSize) {
+            throw new StackFullError();
+        }
+        return super.push(...items);
+    }
+    pop() {
+        if (this.length === 0)
+            throw new StackEmptyError();
+        this.evt.clear();
+        this.totalEntries--;
+        return super.pop();
+    }
+    /**
+     * Awaits a value being available on the stack to retrieve it
+     * @param abortSignal
+     */
+    awaitPop(abortSignal) {
+        if (this.size() === 0) {
+            const future = this.evt.wait();
+            if (abortSignal)
+                future.registerSignal(abortSignal);
+            return future.then((v) => {
+                if (this.size() > 0)
+                    return this.pop();
+                return this.awaitPop(v.signal);
+            });
+        }
+        return Future.completed(this.pop());
+    }
+    /**
+     * Retrieves the last item added to the stack
+     */
+    peek() {
+        return this[this.pointer];
+    }
+    /**
+     * Checks if the stack is empty
+     */
+    get empty() {
+        return this.totalEntries === 0;
+    }
+    /**
+     * Checks if the stack is full
+     */
+    get full() {
+        return this.size() === this.maxSize;
+    }
+    /**
+     * Retrieves the current stack size
+     */
+    size() {
+        return this.totalEntries;
+    }
+    /**
+     * Empty the stack
+     */
+    clear() {
+        while (!this.empty) {
+            this.pop();
+        }
+    }
+}
+
+export { Stack };

package/data-structures/array/Triple.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * An immutable tuple of 3 values
+ */
+class Triple {
+    constructor(_first, _second, _third) {
+        this._first = _first;
+        this._second = _second;
+        this._third = _third;
+    }
+    get first() {
+        return this._first;
+    }
+    get second() {
+        return this._second;
+    }
+    get third() {
+        return this._third;
+    }
+    get last() {
+        return this.third;
+    }
+    get values() {
+        return [this._first, this._second, this._third];
+    }
+}
+/**
+ * Creates an immutable tuple of 3 values
+ */
+const triple = (first, second, third) => new Triple(first, second, third);
+
+exports.Triple = Triple;
+exports.triple = triple;

package/data-structures/array/Triple.d.ts

@@ -0,0 +1,19 @@
+import { Tuple } from "./Tuple";
+/**
+ * An immutable tuple of 3 values
+ */
+export declare class Triple<T, V, K> implements Tuple<T, K> {
+    private readonly _first;
+    private readonly _second;
+    private readonly _third;
+    constructor(_first: T, _second: V, _third: K);
+    get first(): T;
+    get second(): V;
+    get third(): K;
+    get last(): K;
+    get values(): [T, V, K];
+}
+/**
+ * Creates an immutable tuple of 3 values
+ */
+export declare const triple: <T, V, K>(first: T, second: V, third: K) => Triple<T, V, K>;

package/data-structures/array/Triple.mjs

@@ -0,0 +1,31 @@
+/**
+ * An immutable tuple of 3 values
+ */
+class Triple {
+    constructor(_first, _second, _third) {
+        this._first = _first;
+        this._second = _second;
+        this._third = _third;
+    }
+    get first() {
+        return this._first;
+    }
+    get second() {
+        return this._second;
+    }
+    get third() {
+        return this._third;
+    }
+    get last() {
+        return this.third;
+    }
+    get values() {
+        return [this._first, this._second, this._third];
+    }
+}
+/**
+ * Creates an immutable tuple of 3 values
+ */
+const triple = (first, second, third) => new Triple(first, second, third);
+
+export { Triple, triple };

package/data-structures/array/Tuple.d.ts

@@ -0,0 +1,8 @@
+/**
+ * An immutable collection of items
+ */
+export interface Tuple<T, V> {
+    get first(): T;
+    get last(): V;
+    get values(): any[];
+}

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

@@ -0,0 +1,5 @@
+export { CyclicalList } from "./CyclicalList";
+export { Stack } from "./Stack";
+export { Pair, pair } from "./Pair";
+export { Triple, triple } from "./Triple";
+export { Tuple } from "./Tuple";

package/data-structures/array.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var CyclicalList = require('./array/CyclicalList.cjs');
+var Stack = require('./array/Stack.cjs');
+var Pair = require('./array/Pair.cjs');
+var Triple = require('./array/Triple.cjs');
+
+
+
+exports.CyclicalList = CyclicalList.CyclicalList;
+exports.Stack = Stack.Stack;
+exports.Pair = Pair.Pair;
+exports.pair = Pair.pair;
+exports.Triple = Triple.Triple;
+exports.triple = Triple.triple;

package/data-structures/array.mjs

@@ -0,0 +1,4 @@
+export { CyclicalList } from './array/CyclicalList.mjs';
+export { Stack } from './array/Stack.mjs';
+export { Pair, pair } from './array/Pair.mjs';
+export { Triple, triple } from './array/Triple.mjs';