semantic-typescript 0.3.0 → 0.3.7

package/dist/collector.d.ts

@@ -1,7 +1,7 @@
 import type { Collectable } from "./collectable";
 import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
-import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer } from "./utility";
+import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer, type Comparator } from "./utility";
 export declare class Collector<E, A, R> {
     protected identity: Supplier<A>;
     protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
@@ -49,10 +49,20 @@ export interface UseError {
     <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
     <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
 }
-export declare let useError: UseLog;
+export declare let useError: UseError;
 export declare let useFindFirst: <E>() => Collector<E, Optional<E>, Optional<E>>;
 export declare let useFindAny: <E>() => Collector<E, Optional<E>, Optional<E>>;
 export declare let useFindLast: <E>() => Collector<E, Optional<E>, Optional<E>>;
+export interface UseFindMaximum {
+    <E>(): Collector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
+}
+export declare let useFindMaximum: UseFindMaximum;
+export interface UseFindMinimum {
+    <E>(): Collector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
+}
+export declare let useFindMinimum: UseFindMinimum;
 export interface UseForEach {
     <E>(action: Consumer<E>): Collector<E, bigint, bigint>;
     <E>(action: BiConsumer<E, bigint>): Collector<E, bigint, bigint>;
@@ -97,28 +107,95 @@ export interface UseWrite {
     <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
 }
 export declare let useWrite: UseWrite;
-export type NumericAverageInformation = {
+export interface UseNumericSummate {
+    <E>(): Collector<E, number, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, number, number>;
+}
+export declare let useNumericSummate: UseNumericSummate;
+export interface UseBigIntSummate {
+    <E>(): Collector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, bigint, bigint>;
+}
+export declare let useBigIntSummate: UseBigIntSummate;
+export interface UseNumericAverage {
+    <E>(): Collector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, NumericAverageAccumulator, number>;
+}
+export interface NumericAverageAccumulator {
     summate: number;
     count: number;
-};
-export interface UseNumericAverage {
-    (): Collector<number, NumericAverageInformation, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, NumericAverageInformation, number>;
 }
 export declare let useNumericAverage: UseNumericAverage;
-export type BigIntAverageInformation = {
+export interface UseBigIntAverage {
+    <E>(): Collector<E, BigIntAverageAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageAccumulator, bigint>;
+}
+export interface BigIntAverageAccumulator {
     summate: bigint;
     count: bigint;
-};
-export interface UseBigIntAverage {
-    (): Collector<bigint, BigIntAverageInformation, bigint>;
-    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageInformation, bigint>;
 }
 export declare let useBigIntAverage: UseBigIntAverage;
 export declare let useFrequency: <E>() => Collector<E, Map<E, bigint>, Map<E, bigint>>;
-export interface UseNumericSummate {
-    (): Collector<number, number, number>;
-    <E>(mapper: Functional<E, number>): Collector<E, number, number>;
+export interface UseNumericMode {
+    <E>(): Collector<E, Map<number, bigint>, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, Map<number, bigint>, number>;
+}
+export declare let useNumericMode: UseNumericMode;
+export interface UseBigIntMode {
+    <E>(): Collector<E, Map<bigint, bigint>, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, Map<bigint, bigint>, bigint>;
+}
+export declare let useBigIntMode: UseBigIntMode;
+export interface UseNumericVariance {
+    <E>(): Collector<E, VarianceAccumulator, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, VarianceAccumulator, number>;
+}
+export interface VarianceAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useNumericVariance: UseNumericVariance;
+export interface UseBigIntVariance {
+    <E>(): Collector<E, BigIntVarianceAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntVarianceAccumulator, bigint>;
+}
+export interface BigIntVarianceAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useBigIntVariance: UseBigIntVariance;
+export interface UseNumericStandardDeviation {
+    <E>(): Collector<E, StandardDeviationAccumulator, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, StandardDeviationAccumulator, number>;
+}
+export interface StandardDeviationAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useNumericStandardDeviation: UseNumericStandardDeviation;
+export interface UseBigIntStandardDeviation {
+    <E>(): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
+}
+export interface BigIntStandardDeviationAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useBigIntStandardDeviation: UseBigIntStandardDeviation;
+export interface UseNumericMedian {
+    <E>(): Collector<E, number[], number>;
+    <E>(mapper: Functional<E, number>): Collector<E, number[], number>;
+}
+export declare let useNumericMedian: UseNumericMedian;
+export interface UseBigIntMedian {
+    <E>(): Collector<E, bigint[], bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, bigint[], bigint>;
 }
-export declare let useSummate: UseNumericSummate;
+export declare let useBigIntMedian: UseBigIntMedian;
+export declare let useToGeneratorFunction: <E>() => Collector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
+export declare let useToAsyncGeneratorFunction: <E>() => Collector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
 export {};

package/dist/collector.js

@@ -1,4 +1,5 @@
 import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
+import { useCompare, useToBigInt, useToNumber } from "./hook";
 import { Optional } from "./optional";
 import { CollectableSymbol } from "./symbol";
 import { validate, invalidate } from "./utility";
@@ -57,19 +58,7 @@ export class Collector {
         else if (isCollectable(argument1)) {
             let collectable = argument1;
             let source = collectable.source();
-            if (isIterable(source)) {
-                let iterable = source;
-                let index = 0n;
-                for (let element of iterable) {
-                    if (this.interrupt(element, index, accumulator)) {
-                        break;
-                    }
-                    accumulator = this.accumulator(accumulator, element, count);
-                    count++;
-                    index++;
-                }
-            }
-            else if (isFunction(source)) {
+            if (isFunction(source)) {
                 let generator = source;
                 generator((element, index) => {
                     accumulator = this.accumulator(accumulator, element, index);
@@ -143,30 +132,20 @@ export let useCount = () => {
 };
 ;
 export let useError = (argument1, argument2, argument3) => {
-    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-        return Collector.full(() => "[", (accumulator, element) => {
-            if (isString(accumulator) && isString(element)) {
-                return accumulator + element + ",";
-            }
-            return String(accumulator) + String(element) + ",";
-        }, (text) => {
-            let result = text.substring(0, text.length - 1) + "]";
-            console.error(result);
-            return result;
-        });
-    }
-    else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-        let accumulator = argument1;
-        return Collector.full(() => "[", accumulator, (text) => {
-            let result = text.substring(0, text.length - 1) + "]";
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
             console.error(result);
             return result;
         });
     }
-    else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
-        let prefix = argument1;
+    else if (isFunction(argument1)) {
+        let prefix = "[";
         let accumulator = argument2;
-        let suffix = argument3;
+        let suffix = "]";
         return Collector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.error(result);
@@ -174,7 +153,16 @@ export let useError = (argument1, argument2, argument3) => {
         });
     }
     else {
-        throw new TypeError("Invalid arguments.");
+        return Collector.full(() => "[", (accumulator, element) => {
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, Math.max(1, text.length - 1)) + "]";
+            console.error(result);
+            return result;
+        });
     }
 };
 export let useFindFirst = () => {
@@ -201,6 +189,22 @@ export let useFindLast = () => {
         return accumulator;
     }, (accumulator) => accumulator);
 };
+export let useFindMaximum = (comparator = (useCompare)) => {
+    return Collector.full(() => Optional.ofNullable(), (accumulator, element) => {
+        if (accumulator.isPresent()) {
+            return comparator(accumulator.get(), element) > 0 ? accumulator : Optional.ofNullable(element);
+        }
+        return Optional.ofNullable(element);
+    }, (result) => result);
+};
+export let useFindMinimum = (comparator = (useCompare)) => {
+    return Collector.full(() => Optional.ofNullable(), (accumulator, element) => {
+        if (accumulator.isPresent()) {
+            return comparator(accumulator.get(), element) < 0 ? accumulator : Optional.ofNullable(element);
+        }
+        return Optional.ofNullable(element);
+    }, (result) => result);
+};
 ;
 export let useForEach = (action) => {
     if (isFunction(action)) {
@@ -266,30 +270,20 @@ export let useJoin = (argument1, argument2, argument3) => {
 };
 ;
 export let useLog = (argument1, argument2, argument3) => {
-    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-        return Collector.full(() => "[", (accumulator, element) => {
-            if (isString(accumulator) && isString(element)) {
-                return accumulator + element + ",";
-            }
-            return String(accumulator) + String(element) + ",";
-        }, (text) => {
-            let result = text.substring(0, text.length - 1) + "]";
-            console.log(result);
-            return result;
-        });
-    }
-    else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-        let accumulator = argument1;
-        return Collector.full(() => "[", accumulator, (text) => {
-            let result = text.substring(0, text.length - 1) + "]";
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
             console.log(result);
             return result;
         });
     }
-    else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
-        let prefix = argument1;
+    else if (isFunction(argument1)) {
+        let prefix = "[";
         let accumulator = argument2;
-        let suffix = argument3;
+        let suffix = "]";
         return Collector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.log(result);
@@ -297,7 +291,17 @@ export let useLog = (argument1, argument2, argument3) => {
         });
     }
     else {
-        throw new TypeError("Invalid arguments.");
+        return Collector.full(() => "[", (accumulator, element) => {
+            console.log(element);
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, Math.max(1, text.length - 1)) + "]";
+            console.log(result);
+            return result;
+        });
     }
 };
 export let usePartition = (count) => {
@@ -427,63 +431,59 @@ export let useWrite = (argument1, argument2) => {
     throw new TypeError("Invalid arguments.");
 };
 ;
-export let useNumericAverage = (mapper) => {
-    if (isFunction(mapper)) {
-        return Collector.full(() => {
-            return {
-                summate: 0,
-                count: 0
-            };
-        }, (information, element) => {
-            let value = mapper(element);
-            information.summate += value;
-            information.count++;
-            return information;
-        }, (information) => {
-            return information.summate / information.count;
-        });
-    }
+export let useNumericSummate = (mapper = useToNumber) => {
+    return Collector.full(() => 0, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return accumulator + (isNumber(resolved) ? resolved : 0);
+    }, (result) => result);
+};
+;
+export let useBigIntSummate = (mapper = useToBigInt) => {
+    return Collector.full(() => 0n, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return accumulator + (isBigInt(resolved) ? resolved : 0n);
+    }, (result) => result);
+};
+;
+;
+export let useNumericAverage = (mapper = useToNumber) => {
     return Collector.full(() => {
         return {
             summate: 0,
             count: 0
         };
-    }, (information, element) => {
-        information.summate += element;
-        information.count++;
-        return information;
-    }, (information) => {
-        return information.summate / information.count;
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count === 0) {
+            return 0;
+        }
+        return result.summate / result.count;
     });
 };
 ;
-export let useBigIntAverage = (mapper) => {
-    if (isFunction(mapper)) {
-        return Collector.full(() => {
-            return {
-                summate: 0n,
-                count: 0n
-            };
-        }, (information, element) => {
-            let value = mapper(element);
-            information.summate += value;
-            information.count++;
-            return information;
-        }, (information) => {
-            return information.summate / information.count;
-        });
-    }
+;
+export let useBigIntAverage = (mapper = useToBigInt) => {
     return Collector.full(() => {
         return {
             summate: 0n,
             count: 0n
         };
-    }, (information, element) => {
-        information.summate += element;
-        information.count++;
-        return information;
-    }, (information) => {
-        return information.summate / information.count;
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count === 0n) {
+            return 0n;
+        }
+        return result.summate / result.count;
     });
 };
 export let useFrequency = () => {
@@ -494,14 +494,204 @@ export let useFrequency = () => {
     }, (map) => map);
 };
 ;
-export let useSummate = (mapper) => {
-    if (isFunction(mapper)) {
-        return Collector.full(() => 0, (summate, element) => {
-            let value = mapper(element);
-            return summate + value;
-        }, (summate) => summate);
-    }
-    return Collector.full(() => 0, (summate, element) => {
-        return summate + element;
-    }, (summate) => summate);
+export let useNumericMode = (mapper = useToNumber) => {
+    return Collector.full(() => new Map(), (map, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        let count = map.get(resolved) || 0n;
+        map.set(resolved, count + 1n);
+        return map;
+    }, (map) => {
+        let maxCount = 0n;
+        let mode = 0;
+        for (let [key, value] of map) {
+            if (value > maxCount) {
+                maxCount = value;
+                mode = key;
+            }
+        }
+        return mode;
+    });
+};
+;
+export let useBigIntMode = (mapper = useToBigInt) => {
+    return Collector.full(() => new Map(), (map, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        let count = map.get(resolved) || 0n;
+        map.set(resolved, count + 1n);
+        return map;
+    }, (map) => {
+        let maxCount = 0n;
+        let mode = 0n;
+        for (let [key, value] of map) {
+            if (value > maxCount) {
+                maxCount = value;
+                mode = key;
+            }
+        }
+        return mode;
+    });
+};
+;
+;
+export let useNumericVariance = (mapper = useToNumber) => {
+    return Collector.full(() => {
+        return {
+            summate: 0,
+            summateOfSquares: 0,
+            count: 0
+        };
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            summateOfSquares: accumulator.summateOfSquares + (isNumber(resolved) ? Math.pow(resolved, 2) : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count < 2) {
+            return 0;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - Math.pow(mean, 2);
+        return variance;
+    });
+};
+;
+;
+export let useBigIntVariance = (mapper = useToBigInt) => {
+    return Collector.full(() => {
+        return {
+            summate: 0n,
+            summateOfSquares: 0n,
+            count: 0n
+        };
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            summateOfSquares: accumulator.summateOfSquares + (isBigInt(resolved) ? resolved * resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count < 2n) {
+            return 0n;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - (mean * mean);
+        return variance;
+    });
+};
+;
+;
+export let useNumericStandardDeviation = (mapper = useToNumber) => {
+    return Collector.full(() => {
+        return {
+            summate: 0,
+            summateOfSquares: 0,
+            count: 0
+        };
+    }, (accumulator, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isNumber(resolved) ? resolved : 0),
+            summateOfSquares: accumulator.summateOfSquares + (isNumber(resolved) ? Math.pow(resolved, 2) : 0),
+            count: accumulator.count + 1
+        };
+    }, (result) => {
+        if (result.count < 2) {
+            return 0;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - Math.pow(mean, 2);
+        let standardDeviation = Math.sqrt(variance);
+        return standardDeviation;
+    });
+};
+;
+;
+export let useBigIntStandardDeviation = (mapper = useToBigInt) => {
+    return Collector.full(() => {
+        return {
+            summate: 0n,
+            summateOfSquares: 0n,
+            count: 0n
+        };
+    }, (accumulator, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        return {
+            summate: accumulator.summate + (isBigInt(resolved) ? resolved : 0n),
+            summateOfSquares: accumulator.summateOfSquares + (isBigInt(resolved) ? resolved * resolved : 0n),
+            count: accumulator.count + 1n
+        };
+    }, (result) => {
+        if (result.count < 2n) {
+            return 0n;
+        }
+        let mean = result.summate / result.count;
+        let variance = (result.summateOfSquares / result.count) - (mean * mean);
+        let standardDeviation = BigInt(Math.sqrt(Number(variance)));
+        return standardDeviation;
+    });
+};
+;
+export let useNumericMedian = (mapper = useToNumber) => {
+    return Collector.full(() => [], (array, element) => {
+        let resolved = isNumber(element) ? element : mapper(element);
+        array.push(resolved);
+        array.sort((a, b) => a - b);
+        return array;
+    }, (array) => {
+        let length = array.length;
+        if (length % 2 === 0) {
+            let mid = length / 2;
+            return (array[mid - 1] + array[mid]) / 2;
+        }
+        else {
+            let mid = Math.floor(length / 2);
+            return array[mid];
+        }
+    });
+};
+;
+export let useBigIntMedian = (mapper = useToBigInt) => {
+    return Collector.full(() => [], (array, element) => {
+        let resolved = isBigInt(element) ? element : mapper(element);
+        array.push(resolved);
+        array.sort((a, b) => Number(a - b));
+        return array;
+    }, (array) => {
+        let length = array.length;
+        if (length % 2 === 0) {
+            let mid = length / 2;
+            return (array[Number(mid - 1)] + array[mid]) / 2n;
+        }
+        else {
+            let mid = Math.floor(length / 2);
+            return array[mid];
+        }
+    });
+};
+export let useToGeneratorFunction = () => {
+    return Collector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => {
+        return (function* () {
+            for (let element of array) {
+                yield element;
+            }
+        })();
+    });
+};
+export let useToAsyncGeneratorFunction = () => {
+    return Collector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => {
+        return (async function* () {
+            for (let element of array) {
+                yield element;
+            }
+        })();
+    });
 };

package/dist/factory.d.ts

@@ -1,6 +1,11 @@
 import { Semantic } from "./semantic";
 import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator } from "./utility";
 export declare let animationFrame: Functional<number, Semantic<number>> & BiFunctional<number, number, Semantic<number>>;
+interface Attribute<T> {
+    key: keyof T;
+    value: T[keyof T];
+}
+export declare let attribute: <T extends object>(target: T) => Semantic<Attribute<T>>;
 export declare let blob: Functional<Blob, Semantic<Uint8Array>> & BiFunctional<Blob, bigint, Semantic<Uint8Array>>;
 export declare let empty: <E>() => Semantic<E>;
 export declare let fill: (<E>(element: E, count: bigint) => Semantic<E>) & (<E>(supplier: Supplier<E>, count: bigint) => Semantic<E>);
@@ -11,3 +16,4 @@ export declare let iterate: <E>(generator: Generator<E>) => Semantic<E>;
 export declare let promise: (<T>(promise: Promise<T>) => Semantic<T>);
 export declare let range: BiFunctional<number, number, Semantic<number>> & TriFunctional<number, number, number, Semantic<number>>;
 export declare let websocket: Functional<WebSocket, Semantic<MessageEvent | CloseEvent | Event>>;
+export {};