@elyukai/utils 0.1.6 → 0.2.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.2.0](https://github.com/elyukai/ts-utils/compare/v0.1.7...v0.2.0) (2026-02-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* merge forEach and forEachAsync
+
+### Features
+
+* merge forEach and forEachAsync ([15b419f](https://github.com/elyukai/ts-utils/commit/15b419fa962218a74133ff7ee85ca817c1fc989c))
+
+## [0.1.7](https://github.com/elyukai/ts-utils/compare/v0.1.6...v0.1.7) (2026-02-05)
+
+
+### Features
+
+* add bind function for partiall application ([bc11da5](https://github.com/elyukai/ts-utils/commit/bc11da568c8ce15c071432307abcb7143f40b5ee))
+
 ## [0.1.6](https://github.com/elyukai/ts-utils/compare/v0.1.5...v0.1.6) (2026-01-28)
 
 

package/dist/dictionary.d.ts

@@ -7,6 +7,7 @@ import type { AnyNonNullish } from "./nullable.js";
  * An immutable dictionary mapping strings to values.
  */
 export declare class Dictionary<T extends AnyNonNullish | null, K extends string = string> {
+    #private;
     private record;
     /**
      * Creates a new dictionary from an indexed object.
@@ -62,14 +63,11 @@ export declare class Dictionary<T extends AnyNonNullish | null, K extends string
     keys(): K[];
     /**
      * Calls the given function for each key-value pair in the dictionary.
-     */
-    forEach(fn: (value: T, key: K) => void): void;
-    /**
-     * Calls the given async function for each key-value pair in the dictionary.
      *
-     * The calls are made sequentially.
+     * If the `async` flag is used, the function calls the function with the values sequentially.
      */
-    forEachAsync(fn: (value: T, key: K) => Promise<void>): Promise<void>;
+    forEach(fn: (value: T, key: K) => Promise<void>, async: true): Promise<void>;
+    forEach(fn: (value: T, key: K) => void, async?: false): void;
     /**
      * Create, modify, or remove the value for the given key based on its current value.
      *

package/dist/dictionary.js

@@ -2,6 +2,7 @@
  * Introduces a Dictionary class that represents an immutable mapping from strings to values.
  * @module
  */
+import { Lazy } from "./lazy.js";
 import { omitKeys, omitUndefinedKeys } from "./object.js";
 /**
  * An immutable dictionary mapping strings to values.
@@ -64,11 +65,12 @@ export class Dictionary {
             return this;
         }
     }
+    #size = Lazy.of(() => this.keys().length);
     /**
      * The number of entries in the dictionary.
      */
     get size() {
-        return this.keys().length;
+        return this.#size.value;
     }
     /**
      * Returns an array of key-value pairs in the dictionary.
@@ -88,22 +90,19 @@ export class Dictionary {
     keys() {
         return Object.keys(this.record);
     }
-    /**
-     * Calls the given function for each key-value pair in the dictionary.
-     */
-    forEach(fn) {
-        for (const [key, value] of this.entries()) {
-            fn(value, key);
+    forEach(...args) {
+        const [fn, async] = args;
+        if (async === true) {
+            return (async () => {
+                for (const [key, value] of this.entries()) {
+                    await fn(value, key);
+                }
+            })();
         }
-    }
-    /**
-     * Calls the given async function for each key-value pair in the dictionary.
-     *
-     * The calls are made sequentially.
-     */
-    async forEachAsync(fn) {
-        for (const [key, value] of this.entries()) {
-            await fn(value, key);
+        else {
+            for (const [key, value] of this.entries()) {
+                fn(value, key);
+            }
         }
     }
     /**

package/dist/function.d.ts

@@ -50,3 +50,21 @@ export declare const not: <T>(predicate: (value: T) => boolean) => (value: T) =>
  * ```
  */
 export declare const on: <T, U, V>(accessor: (value: T) => U, combinator: (a: U, b: U) => V) => ((a: T, b: T) => V);
+/**
+ * Returns a function that binds the given arguments to the provided function.
+ *
+ * This is useful for creating partially applied functions or for fixing certain arguments of a function while leaving others flexible.
+ *
+ * @param fn The function to bind arguments to.
+ * @param fixedArgs The arguments to bind to the function.
+ * @returns A new function that takes the remaining arguments and calls the original function with both the fixed and remaining arguments.
+ *
+ * @example
+ * ```ts
+ * const add = (a: number, b: number) => a + b;
+ * const add5 = bind(add, 5);
+ *
+ * console.log(add5(10)); // Output: 15
+ * ```
+ */
+export declare const bind: <A extends unknown[], B extends unknown[], R>(fn: (...args: [...A, ...B]) => R, ...fixedArgs: A) => ((...restArgs: B) => R);

package/dist/function.js

@@ -54,3 +54,21 @@ export const not = (predicate) => (value) => !predicate(value);
  * ```
  */
 export const on = (accessor, combinator) => (a, b) => combinator(accessor(a), accessor(b));
+/**
+ * Returns a function that binds the given arguments to the provided function.
+ *
+ * This is useful for creating partially applied functions or for fixing certain arguments of a function while leaving others flexible.
+ *
+ * @param fn The function to bind arguments to.
+ * @param fixedArgs The arguments to bind to the function.
+ * @returns A new function that takes the remaining arguments and calls the original function with both the fixed and remaining arguments.
+ *
+ * @example
+ * ```ts
+ * const add = (a: number, b: number) => a + b;
+ * const add5 = bind(add, 5);
+ *
+ * console.log(add5(10)); // Output: 15
+ * ```
+ */
+export const bind = (fn, ...fixedArgs) => (...restArgs) => fn(...fixedArgs, ...restArgs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyukai/utils",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "A set of JavaScript helper functions.",
   "files": [
     "dist",