@byloth/core 1.5.3 → 2.0.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byloth/core",
-  "version": "1.5.3",
+  "version": "2.0.0-rc.10",
   "description": "An unopinionated collection of useful functions and classes that I use widely in all my projects. 🔧",
   "keywords": [
     "Core",
@@ -47,21 +47,19 @@
   },
   "types": "./src/index.ts",
   "devDependencies": {
-    "@byloth/eslint-config-typescript": "^2.8.1",
-    "@types/node": "^20.14.11",
-    "@typescript-eslint/eslint-plugin": "^7.16.1",
-    "@typescript-eslint/parser": "^7.16.1",
-    "eslint": "^8.57.0",
-    "husky": "^9.1.1",
-    "typescript": "^5.5.3",
-    "vite": "^5.3.4"
+    "@byloth/eslint-config-typescript": "^3.0.3",
+    "@types/node": "^22.10.1",
+    "husky": "^9.1.7",
+    "typescript": "^5.7.2",
+    "vite": "^5.4.11"
   },
   "scripts": {
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
     "typecheck": "tsc",
-    "lint": "eslint --ext .cjs,.js,.json,.ts --ignore-path .gitignore .",
+    "lint": "eslint .",
+    "test": "vitest",
     "ci": "pnpm install --frozen-lockfile"
   }
 }

package/src/helpers.ts

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
+// @ts-ignore
+export const isBrowser = ((typeof window !== "undefined") && (typeof window.document !== "undefined"));
+
+// @ts-ignore
+export const isNode = ((typeof process !== "undefined") && (process.versions?.node));
+
+// @ts-ignore
+export const isWebWorker = ((typeof self === "object") && (self.constructor?.name === "DedicatedWorkerGlobalScope"));

package/src/index.ts

@@ -1,28 +1,38 @@
-export const VERSION = "1.5.3";
+export const VERSION = "2.0.0-rc.10";
 
 export type { Constructor, Interval, Timeout } from "./core/types.js";
 
+export { isBrowser, isNode, isWebWorker } from "./helpers.js";
+
 export {
     AggregatedIterator,
     AggregatedAsyncIterator,
-    Aggregator,
-    AsyncAggregator,
+    CallableObject,
+    Clock,
+    Countdown,
     DeferredPromise,
     Exception,
     FatalErrorException,
+    FileException,
+    FileExistsException,
     FileNotFoundException,
-    JsonStorage,
+    GameLoop,
+    JSONStorage,
     KeyException,
+    LongRunningTask,
     NotImplementedException,
     NetworkException,
     PermissionException,
+    Publisher,
+    RangeException,
     ReducedIterator,
     ReferenceException,
     RuntimeException,
     SmartIterator,
     SmartAsyncIterator,
     SmartPromise,
-    Subscribers,
+    SwitchableCallback,
+    Thenable,
     TimeoutException,
     TimedPromise,
     TypeException,
@@ -32,20 +42,26 @@ export {
 
 export type {
     AsyncGeneratorFunction,
-    AsyncIterLike,
+    AsyncIteratorLike,
+    Callback,
     FulfilledHandler,
     GeneratorFunction,
     Iteratee,
-    IterLike,
-    KeyIteratee,
-    KeyReducer,
-    KeyTypeGuardIteratee,
-    MaybeAsyncKeyIteratee,
-    MaybeAsyncKeyReducer,
-    MaybeAsyncKeyTypeGuardIteratee,
-    MaybeAsyncReducer,
+    IteratorLike,
+    JSONArray,
+    JSONObject,
+    JSONValue,
+    KeyedIteratee,
+    KeyedReducer,
+    KeyedTypeGuardIteratee,
+    LongRunningTaskOptions,
+    MaybeAsyncKeyedIteratee,
+    MaybeAsyncKeyedReducer,
+    MaybeAsyncKeyedTypeGuardIteratee,
+    MaybeAsyncGeneratorFunction,
     MaybeAsyncIteratee,
-    MaybeAsyncIterLike,
+    MaybeAsyncIteratorLike,
+    MaybeAsyncReducer,
     MaybeAsyncTypeGuardIteratee,
     MaybePromise,
     PromiseExecutor,
@@ -66,7 +82,7 @@ export {
     dateDifference,
     dateRange,
     dateRound,
-    DateUnit,
+    TimeUnit,
     enumerate,
     hash,
     loadScript,
@@ -76,6 +92,7 @@ export {
     shuffle,
     sum,
     unique,
+    yieldToEventLoop,
     zip
 
 } from "./utils/index.js";

package/src/models/aggregators/aggregated-async-iterator.ts

@@ -1,9 +1,15 @@
 import { SmartAsyncIterator } from "../iterators/index.js";
-import type { AsyncGeneratorFunction, GeneratorFunction, MaybeAsyncIterLike } from "../iterators/types.js";
+import type {
+    GeneratorFunction,
+    AsyncGeneratorFunction,
+    MaybeAsyncGeneratorFunction,
+    MaybeAsyncIteratorLike
+
+} from "../iterators/types.js";
 import type { MaybePromise } from "../types.js";
 
 import ReducedIterator from "./reduced-iterator.js";
-import type { MaybeAsyncKeyIteratee, MaybeAsyncKeyTypeGuardIteratee, MaybeAsyncKeyReducer } from "./types.js";
+import type { MaybeAsyncKeyedIteratee, MaybeAsyncKeyedTypeGuardIteratee, MaybeAsyncKeyedReducer } from "./types.js";
 
 export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 {
@@ -15,58 +21,52 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
     public constructor(iterator: AsyncIterator<[K, T]>);
     public constructor(generatorFn: GeneratorFunction<[K, T]>);
     public constructor(generatorFn: AsyncGeneratorFunction<[K, T]>);
-    public constructor(argument: MaybeAsyncIterLike<[K, T]>);
-    public constructor(argument: MaybeAsyncIterLike<[K, T]>)
+    public constructor(argument: MaybeAsyncIteratorLike<[K, T]> | MaybeAsyncGeneratorFunction<[K, T]>);
+    public constructor(argument: MaybeAsyncIteratorLike<[K, T]> | MaybeAsyncGeneratorFunction<[K, T]>)
     {
         this._elements = new SmartAsyncIterator(argument);
     }
 
-    public async every(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    public async every(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
     {
-        const indexes = new Map<K, [number, boolean]>();
+        const values = new Map<K, [number, boolean]>();
 
         for await (const [key, element] of this._elements)
         {
-            const [index, result] = indexes.get(key) ?? [0, true];
+            const [index, result] = values.get(key) ?? [0, true];
 
             if (!(result)) { continue; }
 
-            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+            values.set(key, [index + 1, await predicate(key, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, result]] of indexes)
-            {
-                yield [key, result];
-            }
+            for (const [key, [_, result]] of values) { yield [key, result]; }
         });
     }
-    public async some(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
+    public async some(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, boolean>>
     {
-        const indexes = new Map<K, [number, boolean]>();
+        const values = new Map<K, [number, boolean]>();
 
         for await (const [key, element] of this._elements)
         {
-            const [index, result] = indexes.get(key) ?? [0, false];
+            const [index, result] = values.get(key) ?? [0, false];
 
             if (result) { continue; }
 
-            indexes.set(key, [index + 1, await predicate(key, element, index)]);
+            values.set(key, [index + 1, await predicate(key, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, result]] of indexes)
-            {
-                yield [key, result];
-            }
+            for (const [key, [_, result]] of values) { yield [key, result]; }
         });
     }
 
-    public filter(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>;
-    public filter<S extends T>(predicate: MaybeAsyncKeyTypeGuardIteratee<K, T, S>): AggregatedAsyncIterator<K, S>;
-    public filter(predicate: MaybeAsyncKeyIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>
+    public filter(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>;
+    public filter<S extends T>(predicate: MaybeAsyncKeyedTypeGuardIteratee<K, T, S>): AggregatedAsyncIterator<K, S>;
+    public filter(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): AggregatedAsyncIterator<K, T>
     {
         const elements = this._elements;
 
@@ -78,13 +78,13 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             {
                 const index = indexes.get(key) ?? 0;
 
-                indexes.set(key, index + 1);
-
                 if (await predicate(key, element, index)) { yield [key, element]; }
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public map<V>(iteratee: MaybeAsyncKeyIteratee<K, T, V>): AggregatedAsyncIterator<K, V>
+    public map<V>(iteratee: MaybeAsyncKeyedIteratee<K, T, V>): AggregatedAsyncIterator<K, V>
     {
         const elements = this._elements;
 
@@ -96,31 +96,26 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             {
                 const index = indexes.get(key) ?? 0;
 
-                indexes.set(key, index + 1);
-
                 yield [key, await iteratee(key, element, index)];
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public async reduce(reducer: MaybeAsyncKeyReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
+    public async reduce(reducer: MaybeAsyncKeyedReducer<K, T, T>): Promise<ReducedIterator<K, T>>;
+    public async reduce<A>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>;
-    public async reduce<A>(reducer: MaybeAsyncKeyReducer<K, T, A>, initialValue?: (key: K) => MaybePromise<A>)
+    public async reduce<A>(reducer: MaybeAsyncKeyedReducer<K, T, A>, initialValue?: (key: K) => MaybePromise<A>)
         : Promise<ReducedIterator<K, A>>
     {
-        const accumulators = new Map<K, [number, A]>();
+        const values = new Map<K, [number, A]>();
 
         for await (const [key, element] of this._elements)
         {
             let index: number;
             let accumulator: A;
 
-            if (accumulators.has(key))
-            {
-                [index, accumulator] = accumulators.get(key)!;
-
-                index += 1;
-            }
+            if (values.has(key)) { [index, accumulator] = values.get(key)!; }
             else if (initialValue !== undefined)
             {
                 index = 0;
@@ -128,103 +123,159 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
             }
             else
             {
-                accumulators.set(key, [0, (element as unknown) as A]);
+                values.set(key, [0, (element as unknown) as A]);
 
                 continue;
             }
 
-            accumulator = await reducer(key, accumulator, element, index);
-
-            accumulators.set(key, [index, accumulator]);
+            values.set(key, [index + 1, await reducer(key, accumulator, element, index)]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, [_, accumulator]] of accumulators)
+            for (const [key, [_, accumulator]] of values) { yield [key, accumulator]; }
+        });
+    }
+
+    public flatMap<V>(iteratee: MaybeAsyncKeyedIteratee<K, T, Iterable<V>>): AggregatedAsyncIterator<K, V>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, V]>
+        {
+            const indexes = new Map<K, number>();
+
+            for await (const [key, element] of elements)
             {
-                yield [key, accumulator];
+                const index = indexes.get(key) ?? 0;
+                const values = await iteratee(key, element, index);
+
+                for await (const value of values) { yield [key, value]; }
+
+                indexes.set(key, index + 1);
             }
         });
     }
 
-    public unique(): AggregatedAsyncIterator<K, T>
+    public drop(count: number): AggregatedAsyncIterator<K, T>
     {
         const elements = this._elements;
 
         return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
-            const keys = new Map<K, Set<T>>();
+            const indexes = new Map<K, number>();
 
             for await (const [key, element] of elements)
             {
-                const values = keys.get(key) ?? new Set<T>();
-
-                if (values.has(element)) { continue; }
+                const index = indexes.get(key) ?? 0;
+                if (index < count)
+                {
+                    indexes.set(key, index + 1);
 
-                values.add(element);
-                keys.set(key, values);
+                    continue;
+                }
 
                 yield [key, element];
             }
         });
     }
-
-    public async count(): Promise<ReducedIterator<K, number>>
+    public take(limit: number): AggregatedAsyncIterator<K, T>
     {
-        const counters = new Map<K, number>();
+        const elements = this._elements;
 
-        for await (const [key] of this._elements)
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
         {
-            const count = counters.get(key) ?? 0;
-
-            counters.set(key, count + 1);
-        }
+            const indexes = new Map<K, number>();
 
-        return new ReducedIterator(function* ()
-        {
-            for (const [key, count] of counters)
+            for await (const [key, element] of elements)
             {
-                yield [key, count];
+                const index = indexes.get(key) ?? 0;
+                if (index >= limit) { continue; }
+
+                yield [key, element];
+
+                indexes.set(key, index + 1);
             }
         });
     }
-    public async first(): Promise<ReducedIterator<K, T>>
+
+    public async find(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, T | undefined>>;
+    public async find<S extends T>(predicate: MaybeAsyncKeyedTypeGuardIteratee<K, T, S>)
+        : Promise<ReducedIterator<K, S | undefined>>;
+
+    public async find(predicate: MaybeAsyncKeyedIteratee<K, T, boolean>): Promise<ReducedIterator<K, T | undefined>>
     {
-        const firsts = new Map<K, T>();
+        const values = new Map<K, [number, T | undefined]>();
 
         for await (const [key, element] of this._elements)
         {
-            if (firsts.has(key)) { continue; }
+            let [index, finding] = values.get(key) ?? [0, undefined];
 
-            firsts.set(key, element);
+            if (finding !== undefined) { continue; }
+            if (await predicate(key, element, index)) { finding = element; }
+
+            values.set(key, [index + 1, finding]);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, element] of firsts)
+            for (const [key, [_, finding]] of values) { yield [key, finding]; }
+        });
+    }
+
+    public unique(): AggregatedAsyncIterator<K, T>
+    {
+        const elements = this._elements;
+
+        return new AggregatedAsyncIterator(async function* (): AsyncGenerator<[K, T]>
+        {
+            const keys = new Map<K, Set<T>>();
+
+            for await (const [key, element] of elements)
             {
+                const values = keys.get(key) ?? new Set<T>();
+
+                if (values.has(element)) { continue; }
+
+                values.add(element);
+                keys.set(key, values);
+
                 yield [key, element];
             }
         });
     }
-    public async last(): Promise<ReducedIterator<K, T>>
+
+    public async count(): Promise<ReducedIterator<K, number>>
     {
-        const lasts = new Map<K, T>();
+        const counters = new Map<K, number>();
 
-        for await (const [key, element] of this._elements)
+        for await (const [key] of this._elements)
         {
-            lasts.set(key, element);
+            const count = counters.get(key) ?? 0;
+
+            counters.set(key, count + 1);
         }
 
         return new ReducedIterator(function* ()
         {
-            for (const [key, element] of lasts)
-            {
-                yield [key, element];
-            }
+            for (const [key, count] of counters) { yield [key, count]; }
         });
     }
 
+    public async forEach(iteratee: MaybeAsyncKeyedIteratee<K, T>): Promise<void>
+    {
+        const indexes = new Map<K, number>();
+
+        for await (const [key, element] of this._elements)
+        {
+            const index = indexes.get(key) ?? 0;
+
+            iteratee(key, element, index);
+
+            indexes.set(key, index + 1);
+        }
+    }
+
     public keys(): SmartAsyncIterator<K>
     {
         const elements = this._elements;
@@ -252,10 +303,7 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
 
         return new SmartAsyncIterator<T>(async function* ()
         {
-            for await (const [_, element] of elements)
-            {
-                yield element;
-            }
+            for await (const [_, element] of elements) { yield element; }
         });
     }
 
@@ -294,5 +342,5 @@ export default class AggregatedAsyncIterator<K extends PropertyKey, T>
         return groups;
     }
 
-    public get [Symbol.toStringTag]() { return "AggregatedAsyncIterator"; }
+    public readonly [Symbol.toStringTag]: string = "AggregatedAsyncIterator";
 }