gingersnap 0.22.0

package/synchronize.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+var future = require('./future/future.cjs');
+require('ramda');
+require('./stream.cjs');
+
+/**
+ * An event that is awaitable
+ */
+class FutureEvent {
+    constructor() {
+        this.__internal__ = new EventTarget();
+        this.ready = false;
+    }
+    /**
+     * Checks if the event happened
+     */
+    get isSet() {
+        return this.ready;
+    }
+    /**
+     * Waits for the event to occur
+     * @param period
+     */
+    wait(period) {
+        const future$1 = future.Future.of((resolve, reject, signal) => {
+            if (!this.isSet) {
+                const readyCallback = () => resolve(this);
+                signal.onabort = () => this.__internal__.removeEventListener("ready", readyCallback);
+                this.__internal__.addEventListener("ready", readyCallback, { once: true });
+            }
+            else {
+                resolve(this);
+            }
+        });
+        if (period)
+            return future.Future.waitFor(future$1, period);
+        return future$1;
+    }
+    /**
+     * Notifies all listeners that the event has been triggered
+     */
+    set() {
+        this.ready = true;
+        this.__internal__.dispatchEvent(new Event("ready"));
+    }
+    /**
+     * Resets the event signals, returns to a 'waiting for event' state
+     */
+    clear() {
+        this.ready = false;
+    }
+}
+/**
+ * A mutex lock for asynchronous operations
+ */
+class Lock {
+    constructor() {
+        this.__locked__ = false;
+        this.evt = new FutureEvent();
+    }
+    /**
+     * Checks if the current lock has been acquired
+     */
+    get locked() {
+        return this.__locked__;
+    }
+    /**
+     * Acquire and release the lock irrespective of the provided function failing.
+     * The function can also return data to the invoker of the with() context
+     * @param functor
+     */
+    with(functor) {
+        return this.acquire()
+            .thenApply(functor)
+            .finally(() => this.release());
+    }
+    /**
+     * Attempts to acquire the lock
+     * @param waitPeriod
+     */
+    acquire(waitPeriod) {
+        if (this.locked) {
+            return this.evt.wait(waitPeriod).thenApply(() => {
+                if (this.locked)
+                    return this.acquire(waitPeriod);
+                this.evt.clear();
+                this.__locked__ = true;
+                return this;
+            });
+        }
+        this.evt.clear();
+        this.__locked__ = true;
+        return future.Future.completed(this);
+    }
+    /**
+     * Releases the lock, allowing the next waiting call to acquire the lock
+     */
+    release() {
+        this.__locked__ = false;
+        this.evt.set();
+    }
+}
+
+exports.FutureEvent = FutureEvent;
+exports.Lock = Lock;

package/synchronize.d.ts

@@ -0,0 +1,54 @@
+import { Future, FutureResult, WaitPeriod } from "./future";
+import { ContextManager } from "./managers";
+/**
+ * An event that is awaitable
+ */
+export declare class FutureEvent {
+    private readonly __internal__;
+    private ready;
+    constructor();
+    /**
+     * Checks if the event happened
+     */
+    get isSet(): boolean;
+    /**
+     * Waits for the event to occur
+     * @param period
+     */
+    wait(period?: WaitPeriod): Future<FutureEvent>;
+    /**
+     * Notifies all listeners that the event has been triggered
+     */
+    set(): void;
+    /**
+     * Resets the event signals, returns to a 'waiting for event' state
+     */
+    clear(): void;
+}
+/**
+ * A mutex lock for asynchronous operations
+ */
+export declare class Lock implements ContextManager<Lock> {
+    private __locked__;
+    private readonly evt;
+    constructor();
+    /**
+     * Checks if the current lock has been acquired
+     */
+    get locked(): boolean;
+    /**
+     * Acquire and release the lock irrespective of the provided function failing.
+     * The function can also return data to the invoker of the with() context
+     * @param functor
+     */
+    with<K>(functor: (value: FutureResult<Lock>) => K): Future<import("./future/result").InferredFutureResult<K>>;
+    /**
+     * Attempts to acquire the lock
+     * @param waitPeriod
+     */
+    acquire(waitPeriod?: WaitPeriod): Future<Lock>;
+    /**
+     * Releases the lock, allowing the next waiting call to acquire the lock
+     */
+    release(): void;
+}

package/synchronize.mjs

@@ -0,0 +1,103 @@
+import { Future } from './future/future.mjs';
+import 'ramda';
+import './stream.mjs';
+
+/**
+ * An event that is awaitable
+ */
+class FutureEvent {
+    constructor() {
+        this.__internal__ = new EventTarget();
+        this.ready = false;
+    }
+    /**
+     * Checks if the event happened
+     */
+    get isSet() {
+        return this.ready;
+    }
+    /**
+     * Waits for the event to occur
+     * @param period
+     */
+    wait(period) {
+        const future = Future.of((resolve, reject, signal) => {
+            if (!this.isSet) {
+                const readyCallback = () => resolve(this);
+                signal.onabort = () => this.__internal__.removeEventListener("ready", readyCallback);
+                this.__internal__.addEventListener("ready", readyCallback, { once: true });
+            }
+            else {
+                resolve(this);
+            }
+        });
+        if (period)
+            return Future.waitFor(future, period);
+        return future;
+    }
+    /**
+     * Notifies all listeners that the event has been triggered
+     */
+    set() {
+        this.ready = true;
+        this.__internal__.dispatchEvent(new Event("ready"));
+    }
+    /**
+     * Resets the event signals, returns to a 'waiting for event' state
+     */
+    clear() {
+        this.ready = false;
+    }
+}
+/**
+ * A mutex lock for asynchronous operations
+ */
+class Lock {
+    constructor() {
+        this.__locked__ = false;
+        this.evt = new FutureEvent();
+    }
+    /**
+     * Checks if the current lock has been acquired
+     */
+    get locked() {
+        return this.__locked__;
+    }
+    /**
+     * Acquire and release the lock irrespective of the provided function failing.
+     * The function can also return data to the invoker of the with() context
+     * @param functor
+     */
+    with(functor) {
+        return this.acquire()
+            .thenApply(functor)
+            .finally(() => this.release());
+    }
+    /**
+     * Attempts to acquire the lock
+     * @param waitPeriod
+     */
+    acquire(waitPeriod) {
+        if (this.locked) {
+            return this.evt.wait(waitPeriod).thenApply(() => {
+                if (this.locked)
+                    return this.acquire(waitPeriod);
+                this.evt.clear();
+                this.__locked__ = true;
+                return this;
+            });
+        }
+        this.evt.clear();
+        this.__locked__ = true;
+        return Future.completed(this);
+    }
+    /**
+     * Releases the lock, allowing the next waiting call to acquire the lock
+     */
+    release() {
+        this.__locked__ = false;
+        this.evt.set();
+    }
+}
+
+export { FutureEvent, Lock };

package/typing/types.d.ts

@@ -0,0 +1,24 @@
+import { WaitableObject, WatchableObject } from "../data-structures/object";
+import { Stream } from "../stream";
+import { Future } from "../future";
+import { InferredFutureResult } from "../future/result";
+import { ExecutorState } from "../stream/state";
+export interface ObjectOf<T> {
+    [string: string]: T;
+}
+export type AnyObject = {
+    [string: string]: AnyDataType;
+} | Map<string, AnyDataType>;
+export type AnyDataType = AnyObject | Blob | void | Response | AnyObject[] | string | string[] | number | number[] | boolean | undefined | null | Date | RegExp | Map<any, any> | WaitableObject<any, any> | WatchableObject<any, any> | boolean[] | File | File[];
+export type AnyType = AnyDataType | Function | Promise<AnyDataType>;
+export type Flattened<T> = T extends Array<infer U> ? Flattened<U> : T;
+export type InferStreamResult<T> = T extends Stream<infer U> ? InferStreamResult<U> : T extends Future<infer U> ? InferredFutureResult<U> : T extends ExecutorState<infer U> ? U : T;
+export type FlagExcludedType<Base, Type> = {
+    [Key in keyof Base]: Base[Key] extends Type ? never : Key;
+};
+export type AllowedNames<Base, Type> = FlagExcludedType<Base, Type>[keyof Base];
+export type OmitType<Base, Type> = Pick<Base, AllowedNames<Base, Type>>;
+export type InferErrorResult<T, K> = T extends undefined | null ? K : T;
+export type UnaryFunctor<K, V> = (v: K) => V;
+export type BinaryFunctor<K1, K2, V> = (v1: K1, v2: K2) => V;
+export type TernaryFunctor<K1, K2, K3, V> = (v1: K1, v2: K2, v3: K3) => V;

package/typing.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/typing.mjs

@@ -0,0 +1 @@
+

package/utils/parser.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var R = require('ramda');
+
+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);
+
+const parse = R__namespace.curry((mapping, data) => {
+    if (typeof data === "string") {
+        return mapping.string(data);
+    }
+    else if (mapping.supportArray && (Array.isArray(data) || data instanceof Array)) {
+        return data.map((v) => parse(mapping, v));
+    }
+    else if (!(Array.isArray(data) || data instanceof Array) && typeof data === "object") {
+        return mapping.object(data);
+    }
+    return mapping.default(data);
+});
+
+exports.parse = parse;

package/utils/parser.d.ts

@@ -0,0 +1,7 @@
+export interface ParserMap {
+    string: Function;
+    object: Function;
+    default: Function;
+    supportArray?: boolean;
+}
+export declare const parse: any;

package/utils/parser.mjs

@@ -0,0 +1,16 @@
+import * as R from 'ramda';
+
+const parse = R.curry((mapping, data) => {
+    if (typeof data === "string") {
+        return mapping.string(data);
+    }
+    else if (mapping.supportArray && (Array.isArray(data) || data instanceof Array)) {
+        return data.map((v) => parse(mapping, v));
+    }
+    else if (!(Array.isArray(data) || data instanceof Array) && typeof data === "object") {
+        return mapping.object(data);
+    }
+    return mapping.default(data);
+});
+
+export { parse };