semantic-typescript 0.3.7 → 0.3.8

package/dist/hook.js

@@ -1,6 +1,6 @@
 import { useToArray } from "./collector";
 import { isBigInt, isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
-import { validate } from "./utility";
+import { invalidate, validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
         return 0;
@@ -166,15 +166,58 @@ export let useArrange = (source, comparator) => {
     return useGenerator([]);
 };
 export let useToNumber = (target) => {
-    if (isNumber(target)) {
-        return 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;
     }
-    let resolved = Reflect.apply(Reflect.get(target, Symbol.toPrimitive), target, ["default"]);
-    return isNumber(resolved) ? resolved : 0;
 };
 export let useToBigInt = (target) => {
-    if (isBigInt(target)) {
-        return 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;
     }
-    return BigInt(useToNumber(target));
+};
+export let useFunction = (target) => {
+    return Object.freeze((...args) => {
+        return target(...args);
+    });
 };

package/dist/index.d.ts

@@ -5,7 +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,7 +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,7 @@
 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>;
@@ -10,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>;
@@ -30,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>;

package/dist/semantic.js

@@ -10,6 +10,21 @@ export class Semantic {
     Semantic = SemanticSymbol;
     constructor(generator) {
         this.generator = generator;
+        Object.defineProperties(this, {
+            "generator": {
+                value: generator,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            "Semantic": {
+                value: SemanticSymbol,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     concat(other) {
         if (isSemantic(other)) {
@@ -50,29 +65,15 @@ export class Semantic {
         }
         throw new TypeError("Invalid arguments.");
     }
-    distinct(comparator) {
-        if (validate(comparator)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let array = [];
-                    this.generator((element, index) => {
-                        if (!array.some((e) => comparator(e, element))) {
-                            array.push(element);
-                            accept(element, index);
-                        }
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on distinct.");
-                }
-            });
-        }
+    distinct(argument1) {
+        let keyExtractor = validate(argument1) ? argument1 : (element) => element;
         return new Semantic((accept, interrupt) => {
             try {
                 let set = new Set();
                 this.generator((element, index) => {
-                    if (!set.has(element)) {
-                        set.add(element);
+                    let key = keyExtractor(element, index);
+                    if (!set.has(key)) {
+                        set.add(key);
                         accept(element, index);
                     }
                 }, interrupt);
@@ -89,7 +90,7 @@ export class Semantic {
                     let dropping = true;
                     this.generator((element, index) => {
                         if (dropping) {
-                            if (!predicate(element)) {
+                            if (!predicate(element, index)) {
                                 dropping = false;
                                 accept(element, index);
                             }
@@ -110,7 +111,7 @@ export class Semantic {
             return new Semantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
-                        if (predicate(element)) {
+                        if (predicate(element, index)) {
                             accept(element, index);
                         }
                     }, interrupt);
@@ -128,8 +129,8 @@ export class Semantic {
                 try {
                     let count = 0n;
                     let stop = false;
-                    this.generator((element) => {
-                        let result = mapper(element);
+                    this.generator((element, index) => {
+                        let result = mapper(element, index);
                         if (isIterable(result)) {
                             for (let subElement of result) {
                                 accept(subElement, count);
@@ -159,8 +160,8 @@ export class Semantic {
                 try {
                     let count = 0n;
                     let stop = false;
-                    this.generator((element) => {
-                        let result = mapper(element);
+                    this.generator((element, index) => {
+                        let result = mapper(element, index);
                         if (isIterable(result)) {
                             for (let subElement of result) {
                                 accept(subElement, count);
@@ -227,7 +228,7 @@ export class Semantic {
                 try {
                     let stop = false;
                     this.generator((element, index) => {
-                        let resolved = mapper(element);
+                        let resolved = mapper(element, index);
                         accept(resolved, index);
                         stop = stop || interrupt(resolved, index);
                     }, () => stop);
@@ -268,7 +269,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments.");
+        throw new TypeError("Invalid arguments on redirect.");
     }
     reverse() {
         return new Semantic((accept, interrupt) => {
@@ -344,7 +345,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments.");
+        throw new TypeError("Invalid arguments on skip.");
     }
     sorted(comparator) {
         if (isFunction(comparator)) {
@@ -363,38 +364,44 @@ export class Semantic {
         }
     }
     sub(start, end) {
-        return new Semantic((accept, interrupt) => {
-            try {
-                let count = 0n;
-                this.generator((element, index) => {
-                    if (count < end) {
-                        count++;
-                        if (count >= start) {
-                            accept(element, index);
+        if (isBigInt(start) && isBigInt(end)) {
+            return new Semantic((accept, interrupt) => {
+                try {
+                    let count = 0n;
+                    this.generator((element, index) => {
+                        if (count < end) {
+                            count++;
+                            if (count >= start) {
+                                accept(element, index);
+                            }
                         }
-                    }
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sub.");
-            }
-        });
+                    }, interrupt);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error on sub.");
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments on sub.");
     }
     takeWhile(predicate) {
-        return new Semantic((accept, interrupt) => {
-            try {
-                this.generator((element, index) => {
-                    if (!predicate(element)) {
-                        interrupt(element, index);
-                        return;
-                    }
-                    accept(element, index);
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on takeWhile.");
-            }
-        });
+        if (isFunction(predicate)) {
+            return new Semantic((accept, interrupt) => {
+                try {
+                    this.generator((element, index) => {
+                        if (!predicate(element, index)) {
+                            interrupt(element, index);
+                            return;
+                        }
+                        accept(element, index);
+                    }, interrupt);
+                }
+                catch (error) {
+                    throw new Error("Uncaught error on takeWhile.");
+                }
+            });
+        }
+        throw new TypeError("Invalid arguments.");
     }
     toCollectable(mapper) {
         if (isFunction(mapper)) {
@@ -469,7 +476,7 @@ export class Semantic {
                 }
             });
         }
-        else if (isBigInt(argument1)) {
+        if (isBigInt(argument1)) {
             let offset = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -482,7 +489,7 @@ export class Semantic {
                 }
             });
         }
-        else if (isFunction(argument1)) {
+        if (isFunction(argument1)) {
             let translator = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -499,3 +506,6 @@ export class Semantic {
     }
 }
 ;
+Object.freeze(Semantic);
+Object.freeze(Semantic.prototype);
+Object.freeze(Object.getPrototypeOf(Semantic.prototype));

package/dist/statistics.js

@@ -7,6 +7,13 @@ export class Statistics extends OrderedCollectable {
     Statistics = StatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "Statistics", {
+            value: StatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
@@ -34,10 +41,20 @@ export class Statistics extends OrderedCollectable {
     }
 }
 ;
+Object.freeze(Statistics);
+Object.freeze(Statistics.prototype);
+Object.freeze(Object.getPrototypeOf(Statistics));
 export class NumericStatistics extends Statistics {
     NumericStatistics = NumericStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "NumericStatistics", {
+            value: NumericStatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
@@ -241,10 +258,20 @@ export class NumericStatistics extends Statistics {
     }
 }
 ;
+Object.freeze(NumericStatistics);
+Object.freeze(NumericStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(NumericStatistics));
 export class BigIntStatistics extends Statistics {
     BigIntStatistics = BigIntStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperty(this, "BigIntStatistics", {
+            value: BigIntStatisticsSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
@@ -445,3 +472,6 @@ export class BigIntStatistics extends Statistics {
     }
 }
 ;
+Object.freeze(BigIntStatistics);
+Object.freeze(BigIntStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(BigIntStatistics));

package/dist/window.js

@@ -7,6 +7,13 @@ export class WindowCollectable extends OrderedCollectable {
     WindowCollectable = WindowCollectableSymbol;
     constructor(parameter, comparator = useCompare) {
         super(parameter, comparator);
+        Object.defineProperty(this, "WindowCollectable", {
+            value: WindowCollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
@@ -58,3 +65,6 @@ export class WindowCollectable extends OrderedCollectable {
     }
 }
 ;
+Object.freeze(WindowCollectable);
+Object.freeze(WindowCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(WindowCollectable));

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",