semantic-typescript 0.3.3 → 0.3.8

package/dist/collectable.js

@@ -1,18 +1,29 @@
-import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindFirst, useFindLast, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, useReduce, useToArray, useToMap, useToSet, useWrite } from "./collector";
-import { from } from "./factory";
-import { isBigInt, isCollector, isFunction, isIterable, isObject, isString } from "./guard";
+import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindFirst, useFindLast, useFindMaximum, useFindMinimum, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, usePartitionBy, useReduce, useToArray, useToAsyncGeneratorFunction, useToGeneratorFunction, useToMap, useToSet, useWrite } from "./collector";
+import { isBigInt, isCollector, isFunction, isObject, isString } from "./guard";
 import { useCompare } from "./hook";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
-import { CollectableSymbol, OrderedCollectableSymbol, UnorderedCollectableSymbol, WindowCollectableSymbol } from "./symbol";
+import { CollectableSymbol, OrderedCollectableSymbol, UnorderedCollectableSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
 export class Collectable {
     Collectable = CollectableSymbol;
     constructor() {
+        Object.defineProperty(this, "Collectable", {
+            value: CollectableSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+        Object.freeze(this);
     }
     anyMatch(predicate) {
         if (isFunction(predicate)) {
-            return useAnyMatch(predicate).collect(this);
+            try {
+                return useAnyMatch(predicate).collect(this);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on anyMatch.");
+            }
         }
         throw new TypeError("Predicate must be a function.");
     }
@@ -20,43 +31,63 @@ export class Collectable {
         return useAllMatch(predicate).collect(this);
     }
     collect(argument1, argument2, argument3, argument4) {
-        if (isCollector(argument1)) {
-            let collector = argument1;
-            return collector.collect(this);
-        }
-        if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
-            let identity = argument1;
-            let accumulator = argument2;
-            let finisher = argument3;
-            return useCollect(identity, accumulator, finisher).collect(this);
-        }
-        if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
-            let identity = argument1;
-            let interrupt = argument2;
-            let accumulator = argument3;
-            let finisher = argument4;
-            return useCollect(identity, interrupt, accumulator, finisher).collect(this);
+        try {
+            if (isCollector(argument1)) {
+                let collector = argument1;
+                return collector.collect(this);
+            }
+            if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
+                let identity = argument1;
+                let accumulator = argument2;
+                let finisher = argument3;
+                return useCollect(identity, accumulator, finisher).collect(this);
+            }
+            if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
+                let identity = argument1;
+                let interrupt = argument2;
+                let accumulator = argument3;
+                let finisher = argument4;
+                return useCollect(identity, interrupt, accumulator, finisher).collect(this);
+            }
+        }
+        catch (error) {
+            throw new Error("Uncaught error on collect.");
         }
         throw new TypeError("Invalid arguments.");
     }
     count() {
-        return useCount().collect(this);
+        return useCount().collect(this.source());
     }
     error(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            useError().collect(this);
+            try {
+                useError().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
         }
         else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            let accumulator = argument1;
-            useError(accumulator).collect(this);
+            try {
+                let accumulator = argument1;
+                useError(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
-            let prefix = argument1;
-            let accumulator = argument2;
-            let suffix = argument3;
-            useError(prefix, accumulator, suffix).collect(this);
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                useError(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on error.");
+            }
         }
-        {
+        else {
             throw new TypeError("Invalid arguments.");
         }
     }
@@ -64,17 +95,55 @@ export class Collectable {
         return this.count() === 0n;
     }
     findAny() {
-        return useFindAny().collect(this);
+        try {
+            return useFindAny().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findAny.");
+        }
     }
     findFirst() {
-        return useFindFirst().collect(this);
+        try {
+            return useFindFirst().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findFirst.");
+        }
     }
     findLast() {
-        return useFindLast().collect(this);
+        try {
+            return useFindLast().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findLast.");
+        }
+    }
+    findMaximum(argument1) {
+        try {
+            let comparator = isFunction(argument1) ? argument1 : useCompare;
+            return useFindMaximum(comparator).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findMaximum.");
+        }
+    }
+    findMinimum(argument1) {
+        try {
+            let comparator = isFunction(argument1) ? argument1 : useCompare;
+            return useFindMinimum(comparator).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on findMinimum.");
+        }
     }
     forEach(action) {
         if (isFunction(action)) {
-            useForEach(action).collect(this);
+            try {
+                useForEach(action).collect(this);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on forEach.");
+            }
         }
         else {
             throw new TypeError("Action must be a function.");
@@ -82,97 +151,162 @@ export class Collectable {
     }
     group(classifier) {
         if (isFunction(classifier)) {
-            return useGroup(classifier).collect(this);
+            try {
+                return useGroup(classifier).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on group.");
+            }
         }
         throw new TypeError("Classifier must be a function.");
     }
     groupBy(keyExtractor, valueExtractor) {
         if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-            return useGroupBy(keyExtractor, valueExtractor).collect(this);
+            try {
+                return useGroupBy(keyExtractor, valueExtractor).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on groupBy.");
+            }
         }
         throw new TypeError("Key and value extractors must be functions.");
     }
     join(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            return useJoin().collect(this);
+            try {
+                return useJoin().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
         }
-        if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            let delimiter = argument1;
-            return useJoin(delimiter).collect(this);
+        else if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let delimiter = argument1;
+                return useJoin(delimiter).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
         }
-        if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
-            let prefix = argument1;
-            let accumulator = argument2;
-            let suffix = argument3;
-            return useJoin(prefix, accumulator, suffix).collect(this);
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                return useJoin(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
         }
-        if (isString(argument1) && isString(argument2) && isString(argument3)) {
-            let prefix = argument1;
-            let delimiter = argument2;
-            let suffix = argument3;
-            return useJoin(prefix, delimiter, suffix).collect(this);
+        else if (isString(argument1) && isString(argument2) && isString(argument3)) {
+            try {
+                let prefix = argument1;
+                let delimiter = argument2;
+                let suffix = argument3;
+                return useJoin(prefix, delimiter, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on join.");
+            }
         }
         throw new TypeError("Invalid arguments.");
     }
     log(argument1, argument2, argument3) {
-        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            useLog().collect(this);
-        }
-        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            let accumulator = argument1;
-            useLog(accumulator).collect(this);
+        if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            try {
+                let accumulator = argument1;
+                useLog(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
         }
         else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
-            let prefix = argument1;
-            let accumulator = argument2;
-            let suffix = argument3;
-            useLog(prefix, accumulator, suffix).collect(this);
+            try {
+                let prefix = argument1;
+                let accumulator = argument2;
+                let suffix = argument3;
+                useLog(prefix, accumulator, suffix).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
         }
-        {
-            throw new TypeError("Invalid arguments.");
+        else {
+            try {
+                useLog().collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on log.");
+            }
         }
     }
     nonMatch(predicate) {
         if (isFunction(predicate)) {
-            return useNoneMatch(predicate).collect(this);
+            try {
+                return useNoneMatch(predicate).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on nonMatch.");
+            }
         }
         throw new TypeError("Predicate must be a function.");
     }
     partition(count) {
         if (isBigInt(count)) {
-            return usePartition(count).collect(this);
+            try {
+                return usePartition(count).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on partition.");
+            }
         }
         throw new TypeError("Count must be a BigInt.");
     }
     partitionBy(classifier) {
-        return this.collect(() => {
-            return [];
-        }, (array, element) => {
-            let index = classifier(element);
-            while (index > BigInt(array.length) - 1n) {
-                array.push([]);
-            }
-            array[Number(index)].push(element);
-            return array;
-        }, (result) => {
-            return result;
-        });
+        if (isFunction(classifier)) {
+            try {
+                let collector = usePartitionBy(classifier);
+                return collector.collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on partitionBy.");
+            }
+        }
+        throw new TypeError("Classifier must be a function.");
     }
     reduce(argument1, argument2, argument3) {
         if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            let accumulator = argument1;
-            return useReduce(accumulator).collect(this);
+            try {
+                let accumulator = argument1;
+                return useReduce(accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
         }
         else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
-            let identity = argument1;
-            let accumulator = argument2;
-            return useReduce(identity, accumulator).collect(this);
+            try {
+                let identity = argument1;
+                let accumulator = argument2;
+                return useReduce(identity, accumulator).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
         }
         else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
-            let identity = argument1;
-            let accumulator = argument2;
-            let finisher = argument3;
-            return useReduce(identity, accumulator, finisher).collect(this);
+            try {
+                let identity = argument1;
+                let accumulator = argument2;
+                let finisher = argument3;
+                return useReduce(identity, accumulator, finisher).collect(this.source());
+            }
+            catch (error) {
+                throw new Error("Uncaught error on reduce.");
+            }
         }
         else {
             throw new TypeError("Invalid arguments.");
@@ -180,143 +314,207 @@ export class Collectable {
     }
     semantic() {
         let source = this.source();
-        if (isIterable(source)) {
-            return from(source);
-        }
-        else if (isFunction(source)) {
-            return new Semantic(source);
+        if (isFunction(source)) {
+            try {
+                return new Semantic(source);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on semantic.");
+            }
         }
         else {
             throw new TypeError("Invalid source.");
         }
     }
     toArray() {
-        return useToArray().collect(this);
+        try {
+            return useToArray().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toArray.");
+        }
     }
     toMap(keyExtractor, valueExtractor) {
-        return useToMap(keyExtractor, valueExtractor).collect(this);
+        try {
+            return useToMap(keyExtractor, valueExtractor).collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toMap.");
+        }
     }
     toSet() {
-        return useToSet().collect(this);
+        try {
+            return useToSet().collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on toSet.");
+        }
     }
     write(argument1, argument2) {
         if (isObject(argument1)) {
-            let stream = argument1;
-            if (isFunction(argument2)) {
-                let accumulator = argument2;
-                return useWrite(stream, accumulator);
+            try {
+                let stream = argument1;
+                if (isFunction(argument2)) {
+                    let accumulator = argument2;
+                    return useWrite(stream, accumulator).collect(this.source());
+                }
+                else {
+                    return useWrite(stream).collect(this.source());
+                }
             }
-            else {
-                return useWrite(stream);
+            catch (error) {
+                throw new Error("Uncaught error on write.");
             }
         }
         throw new TypeError("Invalid arguments.");
     }
 }
 ;
+Object.freeze(Collectable);
+Object.freeze(Collectable.prototype);
+Object.freeze(Object.getPrototypeOf(Collectable.prototype));
 export class UnorderedCollectable extends Collectable {
     UnorderedCollectable = UnorderedCollectableSymbol;
     generator;
-    constructor(generator) {
+    constructor(argument1) {
         super();
-        this.generator = generator;
+        if (isFunction(argument1)) {
+            this.generator = argument1;
+            Object.defineProperties(this, {
+                "UnorderedCollectable": {
+                    value: UnorderedCollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                },
+                "generator": {
+                    value: this.generator,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                }
+            });
+            Object.freeze(this);
+        }
+        else {
+            throw new TypeError("Source must be an iterable or a generator function.");
+        }
     }
     source() {
         return this.generator;
     }
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.generator);
+        }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
+        }
+    }
 }
 ;
+Object.freeze(UnorderedCollectable);
+Object.freeze(UnorderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(UnorderedCollectable.prototype));
 export class OrderedCollectable extends Collectable {
     OrderedCollectable = OrderedCollectableSymbol;
-    ordered = [];
+    buffer;
     constructor(argument1, argument2) {
         super();
-        let buffer = [];
-        if (isIterable(argument1)) {
-            let iterable = argument1;
-            let index = 0n;
-            for (let element of iterable) {
-                buffer.push({
-                    index: index,
-                    value: element
+        if (isFunction(argument1)) {
+            try {
+                if (isFunction(argument2)) {
+                    let collector = useToArray();
+                    this.buffer = collector.collect(argument1).sort(argument2).map((element, index) => {
+                        return {
+                            element: element,
+                            index: BigInt(index)
+                        };
+                    });
+                }
+                else {
+                    let collector = useToArray();
+                    this.buffer = collector.collect(argument1).map((element, index) => {
+                        return {
+                            element: element,
+                            index: BigInt(index)
+                        };
+                    }).sort((a, b) => {
+                        return Number(a.index - b.index);
+                    });
+                }
+                Object.defineProperties(this, {
+                    "OrderedCollectable": {
+                        value: OrderedCollectableSymbol,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    },
+                    "buffer": {
+                        value: this.buffer,
+                        writable: false,
+                        enumerable: false,
+                        configurable: false
+                    }
                 });
-                index++;
+                Object.freeze(this);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on creating buffer.");
             }
-        }
-        else if (isFunction(argument1)) {
-            let generator = argument1;
-            generator((element, index) => {
-                buffer.push({
-                    index: index,
-                    value: element
-                });
-            }, () => false);
         }
         else {
-            throw new TypeError("Invalid arguments.");
+            throw new TypeError("Source must be an iterable or a generator function.");
         }
-        buffer.map((indexed, _index, array) => {
-            let length = BigInt(array.length);
-            return {
-                index: ((indexed.index % length) + length) % length,
-                value: indexed.value
-            };
-        }).sort((a, b) => {
-            if (isFunction(argument2)) {
-                let comparator = argument2;
-                return comparator(a.value, b.value);
-            }
-            else {
-                return useCompare(a.index, b.index);
-            }
-        }).forEach((indexed) => {
-            this.ordered.push(indexed);
-        });
     }
-    source() {
-        return this.ordered.map((indexed) => indexed.value);
+    *[Symbol.iterator]() {
+        try {
+            let collector = useToGeneratorFunction();
+            yield* collector.collect(this.source());
+        }
+        catch (error) {
+            throw new Error("Uncaught error on Generator.");
+        }
     }
-}
-;
-export class WindowCollectable extends OrderedCollectable {
-    WindowCollectable = WindowCollectableSymbol;
-    constructor(parameter, comparator) {
-        if (isIterable(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let collector = useToAsyncGeneratorFunction();
+            yield* collector.collect(this.source());
         }
-        else if (isFunction(parameter)) {
-            if (isFunction(comparator)) {
-                super(parameter, comparator);
-            }
-            else {
-                super(parameter);
-            }
+        catch (error) {
+            throw new Error("Uncaught error on AsyncGenerator.");
         }
     }
-    slide(size, step = 1n) {
-        if (size > 0n && step > 0n) {
-            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);
+    source() {
+        try {
+            return (accept, interrupt) => {
+                for (let indexed of this.buffer) {
+                    if (interrupt(indexed.element, indexed.index)) {
+                        break;
+                    }
+                    accept(indexed.element, indexed.index);
                 }
-                windowStartIndex += step;
-            }
-            return from(windows).map((window) => from(window));
+            };
+        }
+        catch (error) {
+            throw new Error("Uncaught error on creating source.");
         }
-        throw new RangeError("Invalid arguments.");
     }
-    tumble(size) {
-        return this.slide(size, size);
+    isEmpty() {
+        return this.buffer.length === 0;
     }
 }
 ;
+Object.freeze(OrderedCollectable);
+Object.freeze(OrderedCollectable.prototype);
+Object.freeze(Object.getPrototypeOf(OrderedCollectable.prototype));