semantic-typescript 0.4.1 → 0.5.0

package/dist/collectable.js

@@ -1,9 +1,11 @@
-import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindAt, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, usePartitionBy, useReduce, useToArray, useToAsyncGeneratorFunction, useToGeneratorFunction, useToHashMap, useToHashSet, useToMap, useToSet, useWrite } from "./collector";
+import { Collector, useAllMatch, useAnyMatch, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useCollect, useCount, useError, useFindAny, useFindAt, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useFrequency, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, usePartition, usePartitionBy, useReduce, useToArray, useToHashMap, useToHashSet, useToMap, useToSet, useWrite } from "./collector";
+import { from } from "./factory";
 import { isBigInt, isCollector, isFunction, isNumber, isObject, isString } from "./guard";
-import { useCompare } from "./hook";
+import { useCompare, useToBigInt, useToNumber } from "./hook";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
-import { CollectableSymbol, OrderedCollectableSymbol, UnorderedCollectableSymbol } from "./symbol";
+import { BigIntStatisticsSymbol, CollectableSymbol, NumericStatisticsSymbol, OrderedCollectableSymbol, StatisticsSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
 export class Collectable {
     Collectable = CollectableSymbol;
@@ -353,7 +355,7 @@ export class Collectable {
             throw new Error("Uncaught error on toArray.");
         }
     }
-    toMap(keyExtractor, valueExtractor) {
+    toMap(keyExtractor, valueExtractor = (element) => element) {
         try {
             return useToMap(keyExtractor, valueExtractor).collect(this.source());
         }
@@ -361,7 +363,7 @@ export class Collectable {
             throw new Error("Uncaught error on toMap.");
         }
     }
-    toHashMap(keyExtractor, valueExtractor) {
+    toHashMap(keyExtractor, valueExtractor = (element) => element) {
         try {
             return useToHashMap(keyExtractor, valueExtractor).collect(this.source());
         }
@@ -410,11 +412,14 @@ Object.freeze(Collectable.prototype);
 Object.freeze(Object.getPrototypeOf(Collectable));
 export class UnorderedCollectable extends Collectable {
     UnorderedCollectable = UnorderedCollectableSymbol;
-    generator;
+    buffer = new HashMap();
     constructor(argument1) {
         super();
         if (isFunction(argument1)) {
-            this.generator = argument1;
+            let generator = argument1;
+            generator((element, index) => {
+                this.buffer.set(index, element);
+            }, () => false);
             Object.defineProperties(this, {
                 "UnorderedCollectable": {
                     value: UnorderedCollectableSymbol,
@@ -436,12 +441,20 @@ export class UnorderedCollectable extends Collectable {
         }
     }
     source() {
-        return this.generator;
+        return (accept, interrupt) => {
+            for (let [index, element] of this.buffer) {
+                if (interrupt(element, index)) {
+                    break;
+                }
+                accept(element, index);
+            }
+        };
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToGeneratorFunction();
-            yield* collector.collect(this.generator);
+            for (let [_index, element] of this.buffer) {
+                yield element;
+            }
         }
         catch (error) {
             throw new Error("Uncaught error on Generator.");
@@ -449,8 +462,9 @@ export class UnorderedCollectable extends Collectable {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToAsyncGeneratorFunction();
-            yield* collector.collect(this.generator);
+            for (let [_index, element] of this.buffer) {
+                yield element;
+            }
         }
         catch (error) {
             throw new Error("Uncaught error on AsyncGenerator.");
@@ -513,8 +527,9 @@ export class OrderedCollectable extends Collectable {
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToGeneratorFunction();
-            yield* collector.collect(this.source());
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
         }
         catch (error) {
             throw new Error("Uncaught error on Generator.");
@@ -522,8 +537,9 @@ export class OrderedCollectable extends Collectable {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToAsyncGeneratorFunction();
-            yield* collector.collect(this.source());
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
         }
         catch (error) {
             throw new Error("Uncaught error on AsyncGenerator.");
@@ -552,3 +568,556 @@ export class OrderedCollectable extends Collectable {
 Object.freeze(OrderedCollectable);
 Object.freeze(OrderedCollectable.prototype);
 Object.freeze(Object.getPrototypeOf(OrderedCollectable));
+export class Statistics extends OrderedCollectable {
+    Statistics = StatisticsSymbol;
+    constructor(parameter, comparator) {
+        super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "Statistics": {
+                value: StatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    count() {
+        return BigInt(this.buffer.length);
+    }
+    frequency() {
+        return useFrequency().collect(this.source());
+    }
+}
+;
+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.defineProperties(this, {
+            "NumericStatistics": {
+                value: NumericStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    average(mapper) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            if (isFunction(mapper)) {
+                return useNumericAverage(mapper).collect(this.source());
+            }
+            return useNumericAverage().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
+        }
+    }
+    range(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            if (this.count() === 1n) {
+                return 0;
+            }
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let count = this.buffer.length;
+            let minimum = this.buffer[0].element;
+            let maximum = this.buffer[count - 1].element;
+            return mapper(maximum) - mapper(minimum);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
+        }
+    }
+    variance(argument1) {
+        if (this.isEmpty() || this.count() === 1n) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericVariance(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
+        }
+    }
+    standardDeviation(argument1) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericStandardDeviation(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
+        }
+    }
+    mean(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
+        }
+    }
+    median(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericMedian(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on median.");
+        }
+    }
+    mode(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericMode(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
+        }
+    }
+    summate(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            return useNumericSummate(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
+        }
+    }
+    quantile(quantile, argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        if (quantile < 0 || quantile > 1) {
+            throw new RangeError("Invalid quantile.");
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let count = Number(this.count());
+            let index = Math.floor(quantile * count);
+            if (index === count) {
+                index--;
+            }
+            let value = mapper(this.buffer[index].element);
+            return value;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
+        }
+    }
+    interquartileRange(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let lower = this.quantile(0.25, mapper);
+            let upper = this.quantile(0.75, mapper);
+            return upper - lower;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
+    }
+    skewness(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mean = this.mean(mapper);
+            let standardDeviation = this.standardDeviation(mapper);
+            if (standardDeviation === 0) {
+                return 0;
+            }
+            let data = this.toArray().map(item => mapper(item));
+            let summate = 0;
+            for (let value of data) {
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 3);
+            }
+            return summate / data.length;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
+    }
+    kurtosis(argument1) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToNumber;
+            let mean = this.mean(mapper);
+            let standardDeviation = this.standardDeviation(mapper);
+            if (standardDeviation === 0) {
+                return 0;
+            }
+            let data = this.toArray().map(item => mapper(item));
+            let summate = 0;
+            for (let value of data) {
+                let z = (value - mean) / standardDeviation;
+                summate += Math.pow(z, 4);
+            }
+            return summate / (data.length * data.length) - 3;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
+    }
+}
+;
+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.defineProperties(this, {
+            "BigIntStatistics": {
+                value: BigIntStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    average(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on average.");
+        }
+    }
+    range(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let count = this.buffer.length;
+            let minimum = this.buffer[0].element;
+            let maximum = this.buffer[count - 1].element;
+            return mapper(maximum) - mapper(minimum);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on range.");
+        }
+    }
+    variance(argument1) {
+        if (this.isEmpty() || this.count() === 1n) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntVariance(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on variance.");
+        }
+    }
+    standardDeviation(argument1) {
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let variance = this.variance(mapper);
+            return BigInt(Math.sqrt(Number(variance)));
+        }
+        catch (error) {
+            throw new Error("Uncaught error on standardDeviation.");
+        }
+    }
+    mean(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntAverage(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mean.");
+        }
+    }
+    median(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntMedian(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on median.");
+        }
+    }
+    mode(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntMode(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on mode.");
+        }
+    }
+    summate(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            return useBigIntSummate(mapper).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on summate.");
+        }
+    }
+    quantile(quantile, argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        if (typeof quantile !== "number" || quantile < 0 || quantile > 1) {
+            throw new RangeError("Invalid quantile.");
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let count = Number(this.count());
+            let index = Math.floor(quantile * count);
+            if (index === count) {
+                index--;
+            }
+            let value = mapper(this.buffer[index].element);
+            return value;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on quantile.");
+        }
+    }
+    interquartileRange(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let lower = this.quantile(0.25, mapper);
+            let upper = this.quantile(0.75, mapper);
+            return upper - lower;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on interquartileRange.");
+        }
+    }
+    skewness(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mean = this.mean(mapper);
+            let standardDeviation = this.standardDeviation(mapper);
+            if (standardDeviation === 0n) {
+                return 0n;
+            }
+            let data = this.toArray().map(item => mapper(item));
+            let summate = 0n;
+            for (let value of data) {
+                let z = value - mean;
+                summate += z * z * z;
+            }
+            return summate / BigInt(data.length);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on skewness.");
+        }
+    }
+    kurtosis(argument1) {
+        if (this.isEmpty()) {
+            return 0n;
+        }
+        try {
+            let mapper = isFunction(argument1) ? argument1 : useToBigInt;
+            let mean = this.mean(mapper);
+            let standardDeviation = this.standardDeviation(mapper);
+            if (standardDeviation === 0n) {
+                return 0n;
+            }
+            let data = this.toArray().map(item => mapper(item));
+            let summate = 0n;
+            let count = data.length;
+            for (let value of data) {
+                let z = value - mean;
+                summate += z * z * z * z;
+            }
+            return summate / BigInt(count * count) - 3n;
+        }
+        catch (error) {
+            throw new Error("Uncaught error on kurtosis.");
+        }
+    }
+}
+;
+Object.freeze(BigIntStatistics);
+Object.freeze(BigIntStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(BigIntStatistics));
+export class WindowCollectable extends OrderedCollectable {
+    WindowCollectable = WindowCollectableSymbol;
+    constructor(parameter, comparator = useCompare) {
+        super(parameter, comparator);
+        Object.defineProperties(this, {
+            "WindowCollectable": {
+                value: WindowCollectableSymbol,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
+    }
+    *[Symbol.iterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for (let indexed of this.buffer) {
+                yield indexed.element;
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
+    slide(size, step = 1n) {
+        if (size > 0n && step > 0n) {
+            try {
+                let source = this.toArray();
+                let windows = [];
+                let windowStartIndex = 0n;
+                while (windowStartIndex < BigInt(source.length)) {
+                    let windowEnd = windowStartIndex + size;
+                    let window = source.slice(Number(windowStartIndex), Number(windowEnd));
+                    if (window.length > 0) {
+                        windows.push(window);
+                    }
+                    windowStartIndex += step;
+                }
+                return from(windows).map((window) => from(window));
+            }
+            catch (error) {
+                throw new Error("Invalid arguments.");
+            }
+        }
+        throw new RangeError("Invalid arguments.");
+    }
+    tumble(size) {
+        try {
+            return this.slide(size, size);
+        }
+        catch (error) {
+            throw new Error("Invalid arguments.");
+        }
+    }
+}
+;
+Object.freeze(WindowCollectable);
+Object.freeze(WindowCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(WindowCollectable));

package/dist/collector.d.ts

@@ -94,6 +94,7 @@ interface UseGroup {
 }
 export declare let useGroup: UseGroup;
 interface UseGroupBy {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
     <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
 }
@@ -131,11 +132,13 @@ interface UseReduce {
 export declare let useReduce: UseReduce;
 export declare let useToArray: <E>() => Collector<E, E[], E[]>;
 interface UseToMap {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E>, Map<K, E>>;
     <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V>, Map<K, V>>;
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V>, Map<K, V>>;
 }
 export declare let useToMap: UseToMap;
 interface UseToHashMap {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, HashMap<K, E>, HashMap<K, E>>;
     <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
     <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
 }