@byloth/core 1.5.0-rc.6 → 1.5.0-rc.8

package/src/models/aggregators/aggregator.ts

@@ -1,7 +1,7 @@
 import AggregatedIterator from "./aggregated-iterator.js";
 
 import { SmartIterator } from "../iterators/index.js";
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee } from "../iterators/types.js";
+import type { GeneratorFunction, Iteratee, Iterables, TypeGuardIteratee } from "../iterators/types.js";
 
 export default class Aggregator<T>
 {
@@ -10,8 +10,8 @@ export default class Aggregator<T>
     public constructor(iterable: Iterable<T>);
     public constructor(iterator: Iterator<T>);
     public constructor(generatorFn: GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>);
-    public constructor(argument: Iterable<T> | Iterator<T> | GeneratorFunction<T>)
+    public constructor(argument: Iterables<T>);
+    public constructor(argument: Iterables<T>)
     {
         this._elements = new SmartIterator(argument);
     }

package/src/models/aggregators/async-aggregator.ts

@@ -1,17 +1,27 @@
 import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
 
 import { SmartAsyncIterator } from "../iterators/index.js";
-import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncTypeGuardIteratee } from "../iterators/types.js";
+import type {
+    AsyncGeneratorFunction,
+    GeneratorFunction,
+    MaybeAsyncIterables,
+    MaybeAsyncIteratee,
+    MaybeAsyncTypeGuardIteratee
+
+} from "../iterators/types.js";
 
 export default class AsyncAggregator<T>
 {
     protected _elements: SmartAsyncIterator<T>;
 
+    public constructor(iterable: Iterable<T>);
     public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: Iterator<T>);
     public constructor(iterator: AsyncIterator<T>);
+    public constructor(generatorFn: GeneratorFunction<T>);
     public constructor(generatorFn: AsyncGeneratorFunction<T>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T> | AsyncGeneratorFunction<T>)
+    public constructor(argument: MaybeAsyncIterables<T>);
+    public constructor(argument: MaybeAsyncIterables<T>)
     {
         this._elements = new SmartAsyncIterator(argument);
     }

package/src/models/aggregators/reduced-iterator.ts

@@ -1,7 +1,8 @@
+import { TypeException } from "../exceptions/index.js";
 import { SmartIterator } from "../iterators/index.js";
 import type { GeneratorFunction } from "../iterators/types.js";
 
-import type { KeyIteratee, KeyTypeGuardIteratee } from "./types.js";
+import type { KeyIteratee, KeyReducer, KeyTypeGuardIteratee } from "./types.js";
 
 export default class ReducedIterator<K extends PropertyKey, T>
 {
@@ -45,6 +46,38 @@ export default class ReducedIterator<K extends PropertyKey, T>
             }
         });
     }
+    public reduce(reducer: KeyReducer<K, T, T>): T;
+    public reduce<A>(reducer: KeyReducer<K, T, A>, initialValue: A): A;
+    public reduce<A>(reducer: KeyReducer<K, T, A>, initialValue?: A): A
+    {
+        let index = 0;
+        let accumulator: A;
+
+        if (initialValue !== undefined)
+        {
+            accumulator = initialValue;
+        }
+        else
+        {
+            const firstElement = this._elements.next();
+            if (firstElement.done)
+            {
+                throw new TypeException("Reduce of empty iterator with no initial value");
+            }
+
+            index += 1;
+            accumulator = (firstElement.value[1] as unknown) as A;
+        }
+
+        for (const [key, element] of this._elements)
+        {
+            accumulator = reducer(key, accumulator, element, index);
+
+            index += 1;
+        }
+
+        return accumulator;
+    }
 
     public keys(): SmartIterator<K>
     {

package/src/models/aggregators/types.ts

@@ -7,7 +7,7 @@ export type MaybeAsyncKeyIteratee<K extends PropertyKey, T, R = void> = (key: K,
 export type KeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
     (key: K, value: T, index: number) => value is R;
 export type MaybeAsyncKeyTypeGuardIteratee<K extends PropertyKey, T, R extends T> =
-    (key: K, value: MaybePromise<T>, index: number) => value is MaybePromise<R>;
+    (key: K, value: MaybePromise<T>, index: number) => value is Awaited<R>;
 
 export type KeyReducer<K extends PropertyKey, T, A> = (key: K, accumulator: A, value: T, index: number) => A;
 export type MaybeAsyncKeyReducer<K extends PropertyKey, T, A> =

package/src/models/exceptions/core.ts

@@ -41,3 +41,34 @@ export default class Exception extends Error
 
     public get [Symbol.toStringTag]() { return "Exception"; }
 }
+
+export class FatalErrorException extends Exception
+{
+    public constructor(message?: string, cause?: unknown, name = "FatalErrorException")
+    {
+        if (message === undefined)
+        {
+            message = "The routine has encountered an unrecoverable error and cannot continue as expected. " +
+                "Please, refresh the page and try again. If the problem persists, contact the support team.";
+        }
+
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "FatalErrorException"; }
+}
+
+export class NotImplementedException extends Exception
+{
+    public constructor(message?: string, cause?: unknown, name = "NotImplementedException")
+    {
+        if (message === undefined)
+        {
+            message = "This feature is not implemented yet. Please, try again later.";
+        }
+
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "NotImplementedException"; }
+}

package/src/models/exceptions/index.ts

@@ -1,5 +1,32 @@
 import Exception from "./core.js";
 
+export class FileNotFoundException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "FileNotFoundException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "FileNotFoundException"; }
+}
+export class NetworkException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "NetworkException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "NetworkException"; }
+}
+export class PermissionException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "PermissionException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "PermissionException"; }
+}
 export class ReferenceException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "ReferenceException")
@@ -9,6 +36,15 @@ export class ReferenceException extends Exception
 
     public get [Symbol.toStringTag]() { return "ReferenceException"; }
 }
+export class RuntimeException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "RuntimeException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "RuntimeException"; }
+}
 export class TimeoutException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "TimeoutException")
@@ -18,6 +54,15 @@ export class TimeoutException extends Exception
 
     public get [Symbol.toStringTag]() { return "TimeoutException"; }
 }
+export class TypeException extends Exception
+{
+    public constructor(message: string, cause?: unknown, name = "TypeException")
+    {
+        super(message, cause, name);
+    }
+
+    public get [Symbol.toStringTag]() { return "TypeException"; }
+}
 export class ValueException extends Exception
 {
     public constructor(message: string, cause?: unknown, name = "ValueException")
@@ -29,3 +74,4 @@ export class ValueException extends Exception
 }
 
 export { Exception };
+export { FatalErrorException, NotImplementedException } from "./core.js";

package/src/models/index.ts

@@ -7,7 +7,21 @@ export {
 
 } from "./aggregators/index.js";
 
-export { Exception, ReferenceException, TimeoutException, ValueException } from "./exceptions/index.js";
+export {
+    Exception,
+    FatalErrorException,
+    NotImplementedException,
+    FileNotFoundException,
+    NetworkException,
+    PermissionException,
+    ReferenceException,
+    RuntimeException,
+    TimeoutException,
+    TypeException,
+    ValueException
+
+} from "./exceptions/index.js";
+
 export { SmartIterator, SmartAsyncIterator } from "./iterators/index.js";
 
 import JsonStorage from "./json-storage.js";

package/src/models/iterators/smart-async-iterator.ts

@@ -1,4 +1,12 @@
-import type { AsyncGeneratorFunction, MaybeAsyncIteratee, MaybeAsyncReducer, TypeGuardIteratee } from "./types.js";
+import type {
+    AsyncGeneratorFunction,
+    GeneratorFunction,
+    MaybeAsyncIteratee,
+    MaybeAsyncReducer,
+    MaybeAsyncIterables,
+    MaybeAsyncTypeGuardIteratee
+
+} from "./types.js";
 
 export default class SmartAsyncIterator<T, R = void, N = undefined> implements AsyncIterator<T, R, N>
 {
@@ -7,23 +15,73 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     public return?: (value?: R) => Promise<IteratorResult<T, R>>;
     public throw?: (error?: unknown) => Promise<IteratorResult<T, R>>;
 
+    public constructor(iterable: Iterable<T>);
     public constructor(iterable: AsyncIterable<T>);
+    public constructor(iterator: Iterator<T, R, N>);
     public constructor(iterator: AsyncIterator<T, R, N>);
-    public constructor(generatorFn: () => AsyncGenerator<T, R, N>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>);
-    public constructor(argument: AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>)
+    public constructor(generatorFn: GeneratorFunction<T, R, N>);
+    public constructor(generatorFn: AsyncGeneratorFunction<T, R, N>);
+    public constructor(argument: MaybeAsyncIterables<T, R, N>);
+    public constructor(argument: MaybeAsyncIterables<T, R, N>)
     {
         if (argument instanceof Function)
         {
-            this._iterator = argument();
+            const generator = argument();
+            if (Symbol.asyncIterator in generator)
+            {
+                this._iterator = generator;
+            }
+            else
+            {
+                this._iterator = (async function* ()
+                {
+                    let next: [] | [N] = [];
+
+                    while (true)
+                    {
+                        const result = generator.next(...next);
+                        if (result.done) { return result.value; }
+
+                        next = [yield result.value];
+                    }
+
+                })();
+            }
         }
         else if (Symbol.asyncIterator in argument)
         {
             this._iterator = argument[Symbol.asyncIterator]() as AsyncIterator<T, R, N>;
         }
+        else if (Symbol.iterator in argument)
+        {
+            const iterator = argument[Symbol.iterator]();
+            this._iterator = (async function* ()
+            {
+                while (true)
+                {
+                    const result = iterator.next();
+                    if (result.done) { return result.value; }
+
+                    yield result.value;
+                }
+
+            })();
+        }
         else
         {
-            this._iterator = argument;
+            this._iterator = (async function* ()
+            {
+                let next: [] | [N] = [];
+
+                while (true)
+                {
+                    const result: IteratorResult<T, R> = await argument.next(...next);
+                    if (result.done) { return result.value; }
+
+                    next = [yield result.value];
+                }
+
+            })();
         }
 
         if (this._iterator.return) { this.return = (value?: R) => this._iterator.return!(value); }
@@ -62,7 +120,7 @@ export default class SmartAsyncIterator<T, R = void, N = undefined> implements A
     }
 
     public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartAsyncIterator<T, S>;
+    public filter<S extends T>(predicate: MaybeAsyncTypeGuardIteratee<T, S>): SmartAsyncIterator<S, R>;
     public filter(predicate: MaybeAsyncIteratee<T, boolean>): SmartAsyncIterator<T, R>
     {
         const iterator = this._iterator;

package/src/models/iterators/smart-iterator.ts

@@ -1,4 +1,4 @@
-import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer } from "./types.js";
+import type { GeneratorFunction, Iteratee, TypeGuardIteratee, Reducer, Iterables } from "./types.js";
 
 export default class SmartIterator<T, R = void, N = undefined> implements Iterator<T, R, N>
 {
@@ -10,8 +10,8 @@ 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>)
+    public constructor(argument: Iterables<T, R, N>);
+    public constructor(argument: Iterables<T, R, N>)
     {
         if (argument instanceof Function)
         {
@@ -62,7 +62,7 @@ export default class SmartIterator<T, R = void, N = undefined> implements Iterat
     }
 
     public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartIterator<T, S>;
+    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): SmartIterator<S, R>;
     public filter(predicate: Iteratee<T, boolean>): SmartIterator<T, R>
     {
         const iterator = this._iterator;

package/src/models/iterators/types.ts

@@ -12,3 +12,9 @@ export type MaybeAsyncTypeGuardIteratee<T, R extends T> = (value: MaybePromise<T
 
 export type Reducer<T, A> = (accumulator: A, value: T, index: number) => A;
 export type MaybeAsyncReducer<T, A> = (accumulator: A, value: T, index: number) => MaybePromise<A>;
+
+export type Iterables<T, R = void, N = undefined> = Iterable<T> | Iterator<T, R, N> | GeneratorFunction<T, R, N>;
+export type AsyncIterables<T, R = void, N = undefined> =
+    AsyncIterable<T> | AsyncIterator<T, R, N> | AsyncGeneratorFunction<T, R, N>;
+
+export type MaybeAsyncIterables<T, R = void, N = undefined> = Iterables<T, R, N> | AsyncIterables<T, R, N>;