@byloth/core 1.2.0 → 1.3.0-rc.1

package/src/models/index.ts

@@ -1,7 +1,18 @@
-import DeferredPromise from "./deferred-promise.js";
 import Exception from "./exception.js";
-import JsonStorage from "./json-storage.js";
 import SmartIterator from "./smart-iterator.js";
+import Aggregator, { AggregatedIterator, ReducedIterator } from "./aggregators/index.js";
+
+import DeferredPromise from "./deferred-promise.js";
+import JsonStorage from "./json-storage.js";
 import Subscribers from "./subscribers.js";
 
-export { DeferredPromise, Exception, JsonStorage, SmartIterator, Subscribers };
+export {
+    AggregatedIterator,
+    Aggregator,
+    DeferredPromise,
+    Exception,
+    JsonStorage,
+    ReducedIterator,
+    SmartIterator,
+    Subscribers
+};

package/src/models/smart-iterator.ts

@@ -10,6 +10,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     public constructor(iterable: Iterable<T>);
     public constructor(iterator: Iterator<T, R, N>);
     public constructor(generatorFn: GeneratorFunction<T, R, N>);
+    public constructor(argument: Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>);
     public constructor(argument: Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>)
     {
         if (argument instanceof Function)
@@ -60,13 +61,14 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         }
     }
 
-    public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R, N>
+    public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>
     {
-        let index = 0;
         const iterator = this._iterator;
 
-        return new SmartIterator<T, R, N>(function* ()
+        return new SmartIterator<T, R>(function* ()
         {
+            let index = 0;
+
             while (true)
             {
                 const result = iterator.next();
@@ -80,11 +82,12 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     }
     public map<V>(iteratee: Iteratee<T, V>): SmartIterator<V, R>
     {
-        let index = 0;
         const iterator = this._iterator;
 
         return new SmartIterator<V, R>(function* ()
         {
+            let index = 0;
+
             while (true)
             {
                 const result = iterator.next();
@@ -96,10 +99,18 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
             }
         });
     }
-    public reduce<A>(reducer: Reducer<T, A>, initialValue: A): A
+    public reduce<A>(reducer: Reducer<T, A>, initialValue?: A): A
     {
         let index = 0;
         let accumulator = initialValue;
+        if (accumulator === undefined)
+        {
+            const result = this._iterator.next();
+            if (result.done) { throw new TypeError("Reduce of empty iterator with no initial value"); }
+
+            accumulator = (result.value as unknown) as A;
+            index += 1;
+        }
 
         // eslint-disable-next-line no-constant-condition
         while (true)
@@ -113,6 +124,45 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
         }
     }
 
+    public enumerate(): SmartIterator<[number, T], R>
+    {
+        return this.map((value, index) => [index, value]);
+    }
+    public unique(): SmartIterator<T, R>
+    {
+        const iterator = this._iterator;
+
+        return new SmartIterator<T, R>(function* ()
+        {
+            const values = new Set<T>();
+
+            while (true)
+            {
+                const result = iterator.next();
+
+                if (result.done) { return result.value; }
+                if (values.has(result.value)) { continue; }
+
+                values.add(result.value);
+
+                yield result.value;
+            }
+        });
+    }
+
+    public count(): number
+    {
+        let index = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true)
+        {
+            const result = this._iterator.next();
+            if (result.done) { return index; }
+
+            index += 1;
+        }
+    }
     public forEach(iteratee: Iteratee<T>): void
     {
         let index = 0;
@@ -136,7 +186,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
 
     public toArray(): T[]
     {
-        return [...this];
+        return Array.from(this as Iterable<T>);
     }
 
     public [Symbol.iterator](): SmartIterator<T, R, N> { return this; }

package/src/utils/index.ts

@@ -1,6 +1,10 @@
+import Random from "./random.js";
+
 export { delay, nextAnimationFrame } from "./async.js";
 export { dateDifference, dateRange, dateRound, DateUnit } from "./date.js";
 export { loadScript } from "./dom.js";
 export { count, range, shuffle, unique, zip } from "./iterator.js";
-export { average, hash, random, sum } from "./math.js";
+export { average, hash, sum } from "./math.js";
 export { capitalize } from "./string.js";
+
+export { Random };

package/src/utils/iterator.ts

@@ -10,6 +10,21 @@ export function count<T>(elements: Iterable<T>): number
     return _count;
 }
 
+export function enumerate<T>(elements: Iterable<T>): SmartIterator<[number, T]>
+{
+    return new SmartIterator<[number, T]>(function* ()
+    {
+        let index = 0;
+
+        for (const element of elements)
+        {
+            yield [index, element];
+
+            index += 1;
+        }
+    });
+}
+
 export function range(end: number): SmartIterator<number>;
 export function range(start: number, end: number): SmartIterator<number>;
 export function range(start: number, end: number, step: number): SmartIterator<number>;
@@ -31,7 +46,7 @@ export function range(start: number, end?: number, step = 1): SmartIterator<numb
 
 export function shuffle<T>(iterable: Iterable<T>): T[]
 {
-    const array = [...iterable];
+    const array = Array.from(iterable);
 
     for (let index = array.length - 1; index > 0; index -= 1)
     {
@@ -47,13 +62,13 @@ export function unique<T>(elements: Iterable<T>): SmartIterator<T>
 {
     return new SmartIterator<T>(function* ()
     {
-        const seen = new Set<T>();
+        const values = new Set<T>();
 
         for (const element of elements)
         {
-            if (seen.has(element)) { continue; }
+            if (values.has(element)) { continue; }
 
-            seen.add(element);
+            values.add(element);
 
             yield element;
         }

package/src/utils/math.ts

@@ -33,9 +33,10 @@ export function average<T extends number>(values: Iterable<T>, weights?: Iterabl
 export function hash(value: string): number
 {
     let hashedValue = 0;
-    for (let i = 0; i < value.length; i++)
+    for (let index = 0; index < value.length; index += 1)
     {
-        const char = value.charCodeAt(i);
+        const char = value.charCodeAt(index);
+
         hashedValue = ((hashedValue << 5) - hashedValue) + char;
         hashedValue |= 0;
     }
@@ -43,55 +44,6 @@ export function hash(value: string): number
     return hashedValue;
 }
 
-export function random(): number;
-export function random(max: number): number;
-export function random(min: number, max: number): number;
-export function random(min: number, max: number, isDecimal: boolean): number;
-export function random(min: number, max: number, digits: number): number;
-export function random(min: number = 1, max?: number, decimals?: boolean | number): number
-{
-    if (max === undefined)
-    {
-        max = min;
-        min = 0;
-    }
-
-    if (min === max)
-    {
-        return min;
-    }
-
-    let rounder: (value: number) => number;
-
-    if (decimals === true)
-    {
-        rounder = (value) => value;
-    }
-    else if (decimals === undefined)
-    {
-        if (Math.abs(max - min) <= 1)
-        {
-            rounder = (value) => value;
-        }
-        else
-        {
-            rounder = Math.floor;
-        }
-    }
-    else if (decimals === false)
-    {
-        rounder = Math.floor;
-    }
-    else
-    {
-        const digits = 10 ** decimals;
-
-        rounder = (value) => Math.floor(value * digits) / digits;
-    }
-
-    return rounder(Math.random() * (max - min) + min);
-}
-
 export function sum<T extends number>(values: Iterable<T>): number
 {
     let _sum = 0;

package/src/utils/random.ts

@@ -0,0 +1,39 @@
+export default class Random
+{
+    public static Boolean(ratio: number = 0.5): boolean
+    {
+        return (Math.random() < ratio);
+    }
+
+    public static Integer(max: number): number;
+    public static Integer(min: number, max: number): number;
+    public static Integer(min: number, max?: number): number
+    {
+        if (max === undefined)
+        {
+            return Math.floor(Math.random() * min);
+        }
+
+        return Math.floor(Math.random() * (max - min) + min);
+    }
+
+    public static Decimal(max: number): number;
+    public static Decimal(min: number, max: number): number;
+    public static Decimal(min: number, max?: number): number
+    {
+        if (max === undefined)
+        {
+            return (Math.random() * min);
+        }
+
+        return (Math.random() * (max - min) + min);
+    }
+
+    public static Choice<T>(elements: T[]): T
+    {
+        return elements[this.Integer(elements.length)];
+    }
+
+    // eslint-disable-next-line no-useless-constructor
+    private constructor() { }
+}