semantic-typescript 0.1.4 → 0.2.5

package/dist/factory.js

@@ -0,0 +1,248 @@
+import { isBigInt, isFunction, isIterable, isNumber } from "./guard";
+import { useCompare } from "./hook";
+import { Semantic } from "./semantic";
+import { invalidate, validate } from "./utility";
+export let blob = (blob, chunk = 64n * 1024n) => {
+    let size = Number(chunk);
+    if (size <= 0) {
+        throw new RangeError("Chunk size must be positive.");
+    }
+    if (invalidate(blob)) {
+        throw new TypeError("Blob is invalid.");
+    }
+    return new Semantic((accept, interrupt) => {
+        let index = 0n;
+        let stoppable = false;
+        let stream = blob.stream();
+        let reader = stream.getReader();
+        let buffer = new Uint8Array(size);
+        let offset = 0;
+        let read = async (reader) => {
+            if (stoppable) {
+                return reader.cancel().finally(() => reader.releaseLock());
+            }
+            return reader.read().then((result) => {
+                if (result.done) {
+                    if (offset > 0) {
+                        const element = buffer.subarray(0, offset);
+                        if (interrupt(element, index)) {
+                            stoppable = true;
+                        }
+                        else {
+                            accept(element, index);
+                            index++;
+                        }
+                    }
+                    reader.releaseLock();
+                    return;
+                }
+                let chunkData = result.value;
+                let length = chunkData.length;
+                let remaining = size - offset;
+                if (length > remaining) {
+                    buffer.set(chunkData.subarray(0, remaining), offset);
+                    if (interrupt(buffer, index)) {
+                        stoppable = true;
+                    }
+                    else {
+                        accept(buffer, index);
+                        index++;
+                    }
+                    offset = 0;
+                    const leftover = chunkData.subarray(remaining);
+                    if (leftover.length > 0) {
+                        buffer.set(leftover, offset);
+                        offset += leftover.length;
+                        if (offset === size) {
+                            if (interrupt(buffer, index)) {
+                                stoppable = true;
+                            }
+                            else {
+                                accept(buffer, index);
+                                index++;
+                                offset = 0;
+                            }
+                        }
+                    }
+                }
+                else {
+                    buffer.set(chunkData, offset);
+                    offset += length;
+                    if (offset === size) {
+                        if (interrupt(buffer, index)) {
+                            stoppable = true;
+                        }
+                        else {
+                            accept(buffer, index);
+                            index++;
+                            offset = 0;
+                        }
+                    }
+                }
+                if (!stoppable) {
+                    return read(reader);
+                }
+                else {
+                    return reader.cancel().finally(() => reader.releaseLock());
+                }
+            }).catch((error) => {
+                reader.releaseLock();
+                throw error;
+            });
+        };
+        read(reader).catch(() => {
+            reader.releaseLock();
+        });
+    });
+};
+export let empty = () => {
+    return new Semantic(() => { });
+};
+export let fill = (element, count) => {
+    if (validate(element) && count > 0n) {
+        return new Semantic((accept, interrupt) => {
+            for (let i = 0n; i < count; i++) {
+                let item = isFunction(element) ? element() : element;
+                if (interrupt(item, i)) {
+                    break;
+                }
+                accept(item, i);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let from = (iterable) => {
+    if (isIterable(iterable)) {
+        return new Semantic((accept, interrupt) => {
+            let index = 0n;
+            for (let element of iterable) {
+                if (interrupt(element, index)) {
+                    break;
+                }
+                accept(element, index);
+                index++;
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments");
+};
+export let generate = (supplier, interrupt) => {
+    if (isFunction(supplier) && isFunction(interrupt)) {
+        return new Semantic((accept, interrupt) => {
+            let index = 0n;
+            while (true) {
+                let element = supplier();
+                if (interrupt(element, index)) {
+                    break;
+                }
+                accept(element, index);
+                index++;
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments");
+};
+export let interval = (period, delay = 0) => {
+    if (period > 0 && delay >= 0) {
+        return new Semantic((accept, interrupt) => {
+            if (delay > 0) {
+                setTimeout(() => {
+                    let count = 0;
+                    let index = 0n;
+                    let timer = setInterval(() => {
+                        if (interrupt(count, index)) {
+                            clearInterval(timer);
+                        }
+                        accept(count, BigInt(index));
+                        index++;
+                        count += period;
+                    }, period);
+                }, delay);
+            }
+            else {
+                let count = 0;
+                let index = 0n;
+                let timer = setInterval(() => {
+                    if (interrupt(count, index)) {
+                        clearInterval(timer);
+                    }
+                    accept(count, BigInt(index));
+                    index++;
+                    count += period;
+                }, period);
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let iterate = (generator) => {
+    if (isFunction(generator)) {
+        return new Semantic(generator);
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let range = (start, end, step = 1) => {
+    if ((!isNumber(step) && !isBigInt(step)) || (isNumber(step) && useCompare(step, 0) === 0) || (isBigInt(step) && useCompare(step, 0n) === 0)) {
+        throw new TypeError("Step must be numeric and cannot be zero.");
+    }
+    if (isNumber(start) && isNumber(end)) {
+        let minimum = start, maximum = end, limit = Number(step);
+        let condition = limit > 0 ? (i) => i < maximum : (i) => i > maximum;
+        return new Semantic((accept, interrupt) => {
+            for (let i = minimum; condition(i); i += limit) {
+                let value = i;
+                if (interrupt(value, BigInt(i))) {
+                    break;
+                }
+                accept(value, BigInt(i));
+            }
+        });
+    }
+    throw new TypeError("Invalid arguments.");
+};
+export let websocket = (websocket) => {
+    if (invalidate(websocket)) {
+        throw new TypeError("WebSocket is invalid.");
+    }
+    return new Semantic((accept, interrupt) => {
+        let index = 0n;
+        let stop = false;
+        websocket.addEventListener("open", (event) => {
+            if (stop || interrupt(event, index)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+        websocket.addEventListener("message", (event) => {
+            if (stop || interrupt(event, index)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+        websocket.addEventListener("error", (event) => {
+            if (stop || interrupt(event, index)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+        websocket.addEventListener("close", (event) => {
+            if (stop || interrupt(event, index)) {
+                stop = true;
+            }
+            else {
+                accept(event, index);
+                index++;
+            }
+        });
+    });
+};

package/dist/guard.d.ts

@@ -0,0 +1,23 @@
+import type { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import type { Collector } from "./collector";
+import type { Semantic } from "./semantic";
+import type { Statistics } from "./statistics";
+import type { MaybePrimitive, Primitive } from "./utility";
+export declare let isBoolean: (t: unknown) => t is boolean;
+export declare let isString: (t: unknown) => t is string;
+export declare let isNumber: (t: unknown) => t is number;
+export declare let isFunction: (t: unknown) => t is Function;
+export declare let isObject: (t: unknown) => t is object;
+export declare let isSymbol: (t: unknown) => t is symbol;
+export declare let isBigInt: (t: unknown) => t is bigint;
+export declare let isPrimitive: (t: MaybePrimitive<unknown>) => t is Primitive;
+export declare let isIterable: (t: unknown) => t is Iterable<unknown>;
+export declare let isSemantic: (t: unknown) => t is Semantic<unknown>;
+export declare let isCollector: (t: unknown) => t is Collector<unknown, unknown, unknown>;
+export declare let isCollectable: (t: unknown) => t is Collectable<unknown>;
+export declare let isOrderedCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
+export declare let isWindowCollectable: (t: unknown) => t is OrderedCollectable<unknown>;
+export declare let isUnorderedCollectable: (t: unknown) => t is UnorderedCollectable<unknown>;
+export declare let isStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
+export declare let isNumericStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;
+export declare let isBigIntStatistics: (t: unknown) => t is Statistics<unknown, number | bigint>;

package/dist/guard.js

@@ -0,0 +1,85 @@
+import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol } from "./symbol";
+export let isBoolean = (t) => {
+    return typeof t === "boolean";
+};
+export let isString = (t) => {
+    return typeof t === "string";
+};
+export let isNumber = (t) => {
+    return typeof t === "number";
+};
+export let isFunction = (t) => {
+    return typeof t === "function";
+};
+export let isObject = (t) => {
+    return typeof t === "object" && t !== null;
+};
+export let isSymbol = (t) => {
+    return typeof t === "symbol";
+};
+export let isBigInt = (t) => {
+    return typeof t === "bigint";
+};
+export let isPrimitive = (t) => {
+    return isBoolean(t) || isString(t) || isNumber(t) || isSymbol(t) || isBigInt(t) || isFunction(t);
+};
+export let isIterable = (t) => {
+    if (isObject(t)) {
+        return isFunction(Reflect.get(t, Symbol.iterator));
+    }
+    return false;
+};
+export let isSemantic = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "Semantic") === SemanticSymbol;
+    }
+    return false;
+};
+export let isCollector = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "Collector") === CollectorsSymbol;
+    }
+    return false;
+};
+export let isCollectable = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "Collectable") === CollectableSymbol;
+    }
+    return false;
+};
+export let isOrderedCollectable = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "OrderedCollectable") === OrderedCollectableSymbol;
+    }
+    return false;
+};
+export let isWindowCollectable = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "WindowCollectable") === OrderedCollectableSymbol;
+    }
+    return false;
+};
+export let isUnorderedCollectable = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "UnorderedCollectable") === UnorderedCollectableSymbol;
+    }
+    return false;
+};
+export let isStatistics = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "Statistics") === StatisticsSymbol;
+    }
+    return false;
+};
+export let isNumericStatistics = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "NumericStatistics") === NumericStatisticsSymbol;
+    }
+    return false;
+};
+export let isBigIntStatistics = (t) => {
+    if (isObject(t)) {
+        return Reflect.get(t, "BigIntStatistics") === BigIntStatisticsSymbol;
+    }
+    return false;
+};

package/dist/hook.d.ts

@@ -0,0 +1,2 @@
+export declare let useCompare: <T>(t1: T, t2: T) => number;
+export declare let useRandom: <T = number | bigint>(index: T) => T;

package/dist/hook.js

@@ -0,0 +1,64 @@
+import { isFunction, isNumber, isPrimitive } from "./guard";
+export let useCompare = (t1, t2) => {
+    if (t1 === t2 || Object.is(t1, t2)) {
+        return 0;
+    }
+    if (typeof t1 === typeof t2) {
+        switch (typeof t1) {
+            case "string":
+                return t1.localeCompare(t2);
+            case "number":
+                return t1 - t2;
+            case "bigint":
+                return Number(t1 - t2);
+            case "boolean":
+                return t1 === t2 ? 0 : (t1 ? 1 : -1);
+            case "symbol":
+                return Object.prototype.toString.call(t1).localeCompare(Object.prototype.toString.call(t2));
+            case "function":
+                throw new TypeError("Cannot compare functions.");
+            case "undefined":
+                return 0;
+            case "object":
+                if (isFunction(Reflect.get(t1, Symbol.toPrimitive)) && isFunction(Reflect.get(t2, Symbol.toPrimitive))) {
+                    let a = Reflect.apply(Reflect.get(t1, Symbol.toPrimitive), t1, ["default"]);
+                    let b = Reflect.apply(Reflect.get(t2, Symbol.toPrimitive), t2, ["default"]);
+                    if (isPrimitive(a) && isPrimitive(b)) {
+                        return useCompare(a, b);
+                    }
+                }
+                let a = Object.prototype.valueOf.call(t1);
+                let b = Object.prototype.valueOf.call(t2);
+                if (isPrimitive(a) && isPrimitive(b)) {
+                    return useCompare(a, b);
+                }
+                return useCompare(Object.prototype.toString.call(t1), Object.prototype.toString.call(t2));
+            default:
+                throw new TypeError("Invalid type.");
+        }
+    }
+    throw new TypeError("Cannot compare values of different types.");
+};
+export let useRandom = (index) => {
+    if (isNumber(index)) {
+        let x = Number(index);
+        let phi = (1 + Math.sqrt(5)) / 2;
+        let vanDerCorput = (base, n) => {
+            let result = 0;
+            let f = 1 / base;
+            let i = n;
+            while (i > 0) {
+                result += (i % base) * f;
+                i = Math.floor(i / base);
+                f = f / base;
+            }
+            return result;
+        };
+        let h = vanDerCorput(2, x) + vanDerCorput(3, x);
+        let golden = (x * phi) % 1;
+        let lcg = (1103515245 * x + 12345) % 2147483648;
+        let mixed = (h * 0.5 + golden * 0.3 + lcg / 2147483648 * 0.2);
+        return (mixed * 1000000);
+    }
+    throw new TypeError("Invalid input type");
+};

package/dist/index.d.ts

@@ -1 +1,10 @@
+export * from "./factory";
+export * from "./utility";
+export * from "./symbol";
+export * from "./hook";
+export * from "./optional";
 export * from "./semantic";
+export * from "./collectable";
+export * from "./statistics";
+export * from "./collector";
+export * from "./guard";

package/dist/index.js

@@ -1 +1,10 @@
+export * from "./factory";
+export * from "./utility";
+export * from "./symbol";
+export * from "./hook";
+export * from "./optional";
 export * from "./semantic";
+export * from "./collectable";
+export * from "./statistics";
+export * from "./collector";
+export * from "./guard";

package/dist/optional.d.ts

@@ -0,0 +1,18 @@
+import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable } from "./utility";
+export declare class Optional<T> {
+    protected value: MaybeInvalid<T>;
+    protected readonly Optional: Symbol;
+    protected constructor(value: MaybeInvalid<T>);
+    filter(predicate: Predicate<T>): Optional<T>;
+    get(): T;
+    get(defaultValue: T): T;
+    ifPresent(action: Consumer<T>): void;
+    ifPresent(action: Consumer<T>, elseAction: Runnable): void;
+    isEmpty(): boolean;
+    isPresent(): boolean;
+    map<R>(mapper: Functional<T, R>): Optional<R>;
+    static empty<T>(): Optional<T>;
+    static of<T>(value: MaybeInvalid<T>): Optional<T>;
+    static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;
+    static ofNonNull<T>(value: T): Optional<T>;
+}

package/dist/optional.js

@@ -0,0 +1,65 @@
+import { isFunction } from "./guard";
+import { OptionalSymbol } from "./symbol";
+import { invalidate, validate } from "./utility";
+export class Optional {
+    value;
+    Optional = OptionalSymbol;
+    constructor(value) {
+        this.value = value;
+    }
+    filter(predicate) {
+        if (this.isPresent() && isFunction(predicate) && predicate(this.value)) {
+            return new Optional(this.value);
+        }
+        return new Optional((void 0));
+    }
+    get(defaultValue) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        else {
+            if (validate(defaultValue)) {
+                return defaultValue;
+            }
+            else {
+                throw new TypeError("Optional is empty.");
+            }
+        }
+    }
+    ifPresent(action, elseAction) {
+        if (this.isPresent() && isFunction(action)) {
+            action(this.value);
+        }
+        else if (isFunction(elseAction)) {
+            elseAction();
+        }
+    }
+    isEmpty() {
+        return invalidate(this.value);
+    }
+    isPresent() {
+        return validate(this.value);
+    }
+    map(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            return new Optional(mapper(this.value));
+        }
+        return new Optional(null);
+    }
+    static empty() {
+        return new Optional(null);
+    }
+    static of(value) {
+        return Optional.ofNullable(value);
+    }
+    static ofNullable(value = (void 0)) {
+        return new Optional(value);
+    }
+    static ofNonNull(value) {
+        if (validate(value)) {
+            return new Optional(value);
+        }
+        throw new TypeError("Value is not valid");
+    }
+}
+;