semantic-typescript 0.3.3 → 0.3.8

package/dist/guard.js

@@ -1,4 +1,4 @@
-import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol } from "./symbol";
+import { BigIntStatisticsSymbol, CollectableSymbol, CollectorsSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, SemanticSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 export let isBoolean = (t) => {
     return typeof t === "boolean";
 };
@@ -6,7 +6,7 @@ export let isString = (t) => {
     return typeof t === "string";
 };
 export let isNumber = (t) => {
-    return typeof t === "number";
+    return typeof t === "number" && !Number.isNaN(t) && Number.isFinite(t);
 };
 export let isFunction = (t) => {
     return typeof t === "function";
@@ -23,6 +23,12 @@ export let isBigInt = (t) => {
 export let isPrimitive = (t) => {
     return isBoolean(t) || isString(t) || isNumber(t) || isSymbol(t) || isBigInt(t) || isFunction(t);
 };
+export let isAsyncIterable = (t) => {
+    if (isObject(t)) {
+        return isFunction(Reflect.get(t, Symbol.asyncIterator));
+    }
+    return false;
+};
 export let isIterable = (t) => {
     if (isObject(t)) {
         return isFunction(Reflect.get(t, Symbol.iterator));
@@ -55,7 +61,7 @@ export let isOrderedCollectable = (t) => {
 };
 export let isWindowCollectable = (t) => {
     if (isObject(t)) {
-        return Reflect.get(t, "WindowCollectable") === OrderedCollectableSymbol;
+        return Reflect.get(t, "WindowCollectable") === WindowCollectableSymbol;
     }
     return false;
 };
@@ -89,9 +95,27 @@ export let isPromise = (t) => {
     }
     return false;
 };
-export let isAsync = (t) => {
+export let isGenerator = (t) => {
+    if (isFunction(t)) {
+        return t.length === 2;
+    }
+    return false;
+};
+export let isAsyncFunction = (t) => {
+    if (isFunction(t)) {
+        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction";
+    }
+    return false;
+};
+export let isGeneratorFunction = (t) => {
+    if (isFunction(t)) {
+        return Reflect.get(t, Symbol.toStringTag) === "GeneratorFunction";
+    }
+    return false;
+};
+export let isAsyncGeneratorFunction = (t) => {
     if (isFunction(t)) {
-        return Reflect.get(t, Symbol.toStringTag) === "AsyncFunction" && t.constructor.name === "AsyncFunction";
+        return Reflect.get(t, Symbol.toStringTag) === "AsyncGeneratorFunction";
     }
     return false;
 };

package/dist/hook.d.ts

@@ -1,4 +1,17 @@
 import { type BiPredicate, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
+import type { Comparator, Generator } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 export declare let useRandom: <T = number | bigint>(index: T) => T;
 export declare let useTraverse: <T extends object>(t: T, callback: BiPredicate<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;
+export declare let useGenerator: <E>(iterable: Iterable<E>) => Generator<E>;
+interface UseArrange {
+    <E>(source: Iterable<E>): Generator<E>;
+    <E>(source: Iterable<E>, comparator: Comparator<E>): Generator<E>;
+    <E>(source: Generator<E>): Generator<E>;
+    <E>(source: Generator<E>, comparator: Comparator<E>): Generator<E>;
+}
+export declare let useArrange: UseArrange;
+export declare let useToNumber: <T = unknown>(target: T) => number;
+export declare let useToBigInt: <T = unknown>(target: T) => bigint;
+export declare let useFunction: <T extends ((...args: any[]) => any)>(target: T) => T;
+export {};

package/dist/hook.js

@@ -1,5 +1,6 @@
-import { isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
-import { validate } from "./utility";
+import { useToArray } from "./collector";
+import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
+import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
         return 0;
@@ -109,3 +110,114 @@ export let useTraverse = (t, callback) => {
         traverse(t);
     }
 };
+export let useGenerator = (iterable) => {
+    if (isIterable(iterable)) {
+        return (accept, interrupt) => {
+            let index = 0n;
+            for (let element of iterable) {
+                if (interrupt(element, index)) {
+                    break;
+                }
+                accept(element, index);
+            }
+        };
+    }
+    return () => { };
+};
+;
+export let useArrange = (source, comparator) => {
+    if (isIterable(source)) {
+        let buffer = [...source];
+        if (validate(comparator) && isFunction(comparator)) {
+            return useGenerator(buffer.sort(comparator));
+        }
+        else {
+            return useGenerator(buffer.map((element, index) => {
+                return {
+                    element: element,
+                    index: BigInt(((index % buffer.length) + buffer.length) % buffer.length)
+                };
+            }).sort((a, b) => {
+                return Number(a.index - b.index);
+            }).map((indexed) => {
+                return indexed.element;
+            }));
+        }
+    }
+    else if (isFunction(source)) {
+        let collector = useToArray();
+        let buffer = collector.collect(source);
+        if (validate(comparator) && isFunction(comparator)) {
+            return useGenerator(buffer.sort(comparator));
+        }
+        else {
+            return useGenerator(buffer.map((element, index) => {
+                return {
+                    element: element,
+                    index: BigInt(((index % buffer.length) + buffer.length) % buffer.length)
+                };
+            }).sort((a, b) => {
+                return Number(a.index - b.index);
+            }).map((indexed) => {
+                return indexed.element;
+            }));
+        }
+    }
+    return useGenerator([]);
+};
+export let useToNumber = (target) => {
+    switch (typeof target) {
+        case "number":
+            return isNumber(target) ? target : 0;
+        case "boolean":
+            return target ? 1 : 0;
+        case "string":
+            let result = Number(target.trim());
+            return isNumber(result) ? result : 0;
+        case "bigint":
+            return Number(target);
+        case "object":
+            if (invalidate(target)) {
+                return 0;
+            }
+            if (target instanceof Date) {
+                return target.getTime();
+            }
+            if (Reflect.has(target, Symbol.toPrimitive)) {
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                return isNumber(resolved) ? resolved : 0;
+            }
+            return 0;
+        default:
+            return 0;
+    }
+};
+export let useToBigInt = (target) => {
+    switch (typeof target) {
+        case "number":
+            return isNumber(target) ? BigInt(target) : 0n;
+        case "boolean":
+            return target ? 1n : 0n;
+        case "string":
+            let regex = /^[-+]?\d+$/;
+            return regex.test(target) ? BigInt(target.trim()) : 0n;
+        case "bigint":
+            return target;
+        case "object":
+            if (invalidate(target)) {
+                return 0n;
+            }
+            if (Reflect.has(target, Symbol.toPrimitive)) {
+                let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
+                return isBigInt(resolved) ? resolved : BigInt(useToNumber(resolved));
+            }
+            return 0n;
+        default:
+            return 0n;
+    }
+};
+export let useFunction = (target) => {
+    return Object.freeze((...args) => {
+        return target(...args);
+    });
+};

package/dist/index.d.ts

@@ -5,6 +5,6 @@ export * from "./guard";
 export * from "./hook";
 export * from "./optional";
 export * from "./semantic";
-export * from "./symbol";
 export * from "./statistics";
 export * from "./utility";
+export * from "./window";

package/dist/index.js

@@ -5,6 +5,6 @@ export * from "./guard";
 export * from "./hook";
 export * from "./optional";
 export * from "./semantic";
-export * from "./symbol";
 export * from "./statistics";
 export * from "./utility";
+export * from "./window";

package/dist/optional.js

@@ -7,6 +7,21 @@ export class Optional {
     Optional = OptionalSymbol;
     constructor(value) {
         this.value = value;
+        Object.defineProperties(this, {
+            "value": {
+                value: this.value,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            "Optional": {
+                value: this.Optional,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     filter(predicate) {
         if (this.isPresent() && isFunction(predicate) && predicate(this.value)) {
@@ -29,10 +44,20 @@ export class Optional {
     }
     ifPresent(action, elseAction) {
         if (this.isPresent() && isFunction(action)) {
-            action(this.value);
+            try {
+                action(this.value);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on ifPresent.");
+            }
         }
         else if (isFunction(elseAction)) {
-            elseAction();
+            try {
+                elseAction();
+            }
+            catch (error) {
+                throw new Error("Uncaught error on ifPresent elseAction.");
+            }
         }
     }
     isEmpty() {
@@ -43,7 +68,12 @@ export class Optional {
     }
     map(mapper) {
         if (this.isPresent() && isFunction(mapper)) {
-            return new Optional(mapper(this.value));
+            try {
+                return new Optional(mapper(this.value));
+            }
+            catch (error) {
+                throw new Error("Uncaught error on map.");
+            }
         }
         return new Optional(null);
     }
@@ -74,3 +104,6 @@ export class Optional {
     }
 }
 ;
+Object.freeze(Optional);
+Object.freeze(Optional.prototype);
+Object.freeze(Object.getPrototypeOf(Optional));

package/dist/semantic.d.ts

@@ -1,7 +1,8 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
+import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { type Predicate } from "./utility";
-import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator } from "./utility";
+import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate } from "./utility";
+import { WindowCollectable } from "./window";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;
@@ -9,14 +10,24 @@ export declare class Semantic<E> {
     concat(other: Semantic<E>): Semantic<E>;
     concat(other: Iterable<E>): Semantic<E>;
     distinct(): Semantic<E>;
-    distinct(comparator: Comparator<E>): Semantic<E>;
+    distinct<K>(keyExtractor: Functional<E, K>): Semantic<E>;
+    distinct<K>(keyExtractor: BiFunctional<E, bigint, K>): Semantic<E>;
     dropWhile(predicate: Predicate<E>): Semantic<E>;
+    dropWhile(predicate: BiPredicate<E, bigint>): Semantic<E>;
     filter(predicate: Predicate<E>): Semantic<E>;
-    flat(mapper: Functional<E, Iterable<E> | Semantic<E>>): Semantic<E>;
-    flatMap<R>(mapper: Functional<E, Iterable<R> | Semantic<R>>): Semantic<R>;
+    filter(predicate: BiPredicate<E, bigint>): Semantic<E>;
+    flat(mapper: Functional<E, Iterable<E>>): Semantic<E>;
+    flat(mapper: BiFunctional<E, bigint, Iterable<E>>): Semantic<E>;
+    flat(mapper: Functional<E, Semantic<E>>): Semantic<E>;
+    flat(mapper: BiFunctional<E, bigint, Semantic<E>>): Semantic<E>;
+    flatMap<R>(mapper: Functional<E, Iterable<R>>): Semantic<R>;
+    flatMap<R>(mapper: BiFunctional<E, bigint, Iterable<R>>): Semantic<R>;
+    flatMap<R>(mapper: Functional<E, Semantic<R>>): Semantic<R>;
+    flatMap<R>(mapper: BiFunctional<E, bigint, Semantic<R>>): Semantic<R>;
     limit(n: number): Semantic<E>;
     limit(n: bigint): Semantic<E>;
     map<R>(mapper: Functional<E, R>): Semantic<R>;
+    map<R>(mapper: BiFunctional<E, bigint, R>): Semantic<R>;
     peek(consumer: Consumer<E>): Semantic<E>;
     peek(consumer: BiConsumer<E, bigint>): Semantic<E>;
     redirect(redirector: BiFunctional<E, bigint, bigint>): Semantic<E>;
@@ -29,6 +40,7 @@ export declare class Semantic<E> {
     sorted(comparator: Comparator<E>): OrderedCollectable<E>;
     sub(start: bigint, end: bigint): Semantic<E>;
     takeWhile(predicate: Predicate<E>): Semantic<E>;
+    takeWhile(predicate: BiPredicate<E, bigint>): Semantic<E>;
     toCollectable(): Collectable<E>;
     toCollectable<C extends Collectable<E>>(mapper: Functional<Generator<E>, C>): C;
     toBigintStatistics(): BigIntStatistics<E>;
@@ -40,8 +52,3 @@ export declare class Semantic<E> {
     translate(offset: bigint): Semantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
 }
-export interface UseTransform {
-    <E, R>(generator: Generator<E>, mapper: Functional<E, R>): Generator<R>;
-    <E, R>(generator: Generator<E>, mapper: BiFunctional<E, bigint, R>): Generator<R>;
-}
-export declare let useTransform: UseTransform;