@byloth/core 2.0.0-rc.2 → 2.0.0-rc.4

package/src/models/timers/countdown.ts

@@ -9,7 +9,7 @@ import Publisher from "../publisher.js";
 export default class Countdown extends GameLoop
 {
     protected _deferrer?: DeferredPromise<void>;
-    protected _publisher: Publisher<[number], void>;
+    protected _publisher: Publisher<[number]>;
 
     protected _duration: number;
     public get duration(): number
@@ -76,4 +76,6 @@ export default class Countdown extends GameLoop
             lastTick = remainingTime;
         });
     }
+
+    public readonly [Symbol.toStringTag]: string = "Countdown";
 }

package/src/models/types.ts

@@ -1,10 +1,10 @@
 export type {
-    KeyIteratee,
-    MaybeAsyncKeyIteratee,
-    KeyTypeGuardIteratee,
-    MaybeAsyncKeyTypeGuardIteratee,
-    KeyReducer,
-    MaybeAsyncKeyReducer
+    KeyedIteratee,
+    MaybeAsyncKeyedIteratee,
+    KeyedTypeGuardIteratee,
+    MaybeAsyncKeyedTypeGuardIteratee,
+    KeyedReducer,
+    MaybeAsyncKeyedReducer
 
 } from "./aggregators/types.js";
 
@@ -17,9 +17,9 @@ export type {
     MaybeAsyncTypeGuardIteratee,
     Reducer,
     MaybeAsyncReducer,
-    IterLike,
-    AsyncIterLike,
-    MaybeAsyncIterLike
+    IteratorLike,
+    AsyncIteratorLike,
+    MaybeAsyncIteratorLike
 
 } from "./iterators/types.js";
 

package/src/utils/async.ts

@@ -1,9 +1,9 @@
-export async function delay(milliseconds: number): Promise<void>
+export function delay(milliseconds: number): Promise<void>
 {
-    return new Promise<void>((resolve, reject) => setTimeout(resolve, milliseconds));
+    return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
 }
 
-export async function nextAnimationFrame(): Promise<void>
+export function nextAnimationFrame(): Promise<void>
 {
-    return new Promise<void>((resolve, reject) => requestAnimationFrame(() => resolve()));
+    return new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
 }

package/src/utils/date.ts

@@ -1,7 +1,10 @@
+
 import { SmartIterator } from "../models/index.js";
 
 export enum TimeUnit
 {
+    /* eslint-disable @typescript-eslint/prefer-literal-enum-member */
+
     Millisecond = 1,
     Second = 1000,
     Minute = 60 * Second,

package/src/utils/random.ts

@@ -2,7 +2,7 @@ import { ValueException } from "../models/index.js";
 
 export default class Random
 {
-    public static Boolean(ratio: number = 0.5): boolean
+    public static Boolean(ratio = 0.5): boolean
     {
         return (Math.random() < ratio);
     }
@@ -38,6 +38,7 @@ export default class Random
         return elements[Random.Index(elements)];
     }
 
-    // eslint-disable-next-line no-useless-constructor
-    private constructor() { }
+    private constructor() { /* ... */ }
+
+    public readonly [Symbol.toStringTag]: string = "Random";
 }

package/src/models/aggregators/aggregator.ts

@@ -1,46 +0,0 @@
-import AggregatedIterator from "./aggregated-iterator.js";
-
-import { SmartIterator } from "../iterators/index.js";
-import type { GeneratorFunction, Iteratee, IterLike, TypeGuardIteratee } from "../iterators/types.js";
-
-export default class Aggregator<T>
-{
-    protected _elements: SmartIterator<T>;
-
-    public constructor(iterable: Iterable<T>);
-    public constructor(iterator: Iterator<T>);
-    public constructor(generatorFn: GeneratorFunction<T>);
-    public constructor(argument: IterLike<T>);
-    public constructor(argument: IterLike<T>)
-    {
-        this._elements = new SmartIterator(argument);
-    }
-
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>;
-    public filter<S extends T>(predicate: TypeGuardIteratee<T, S>): Aggregator<S>;
-    public filter(predicate: Iteratee<T, boolean>): Aggregator<T>
-    {
-        return new Aggregator(this._elements.filter(predicate));
-    }
-    public map<V>(iteratee: Iteratee<T, V>): Aggregator<V>
-    {
-        return new Aggregator(this._elements.map(iteratee));
-    }
-
-    public unique(): Aggregator<T>
-    {
-        return new Aggregator(this._elements.unique());
-    }
-
-    public groupBy<K extends PropertyKey>(iteratee: Iteratee<T, K>): AggregatedIterator<K, T>
-    {
-        return new AggregatedIterator(this._elements.map((element, index) =>
-        {
-            const key = iteratee(element, index);
-
-            return [key, element] as [K, T];
-        }));
-    }
-
-    public get [Symbol.toStringTag]() { return "Aggregator"; }
-}

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

@@ -1,56 +0,0 @@
-import AggregatedAsyncIterator from "./aggregated-async-iterator.js";
-
-import { SmartAsyncIterator } from "../iterators/index.js";
-import type {
-    AsyncGeneratorFunction,
-    GeneratorFunction,
-    MaybeAsyncIterLike,
-    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: MaybeAsyncIterLike<T>);
-    public constructor(argument: MaybeAsyncIterLike<T>)
-    {
-        this._elements = new SmartAsyncIterator(argument);
-    }
-
-    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>;
-    public filter<S extends T>(predicate: MaybeAsyncTypeGuardIteratee<T, S>): AsyncAggregator<S>;
-    public filter(predicate: MaybeAsyncIteratee<T, boolean>): AsyncAggregator<T>
-    {
-        return new AsyncAggregator(this._elements.filter(predicate));
-    }
-    public map<V>(iteratee: MaybeAsyncIteratee<T, V>): AsyncAggregator<V>
-    {
-        return new AsyncAggregator(this._elements.map(iteratee));
-    }
-
-    public unique(): AsyncAggregator<T>
-    {
-        return new AsyncAggregator(this._elements.unique());
-    }
-
-    public groupBy<K extends PropertyKey>(iteratee: MaybeAsyncIteratee<T, K>): AggregatedAsyncIterator<K, T>
-    {
-        return new AggregatedAsyncIterator(this._elements.map(async (element, index) =>
-        {
-            const key = await iteratee(element, index);
-
-            return [key, element] as [K, T];
-        }));
-    }
-
-    public get [Symbol.toStringTag]() { return "AsyncAggregator"; }
-}