@elyukai/utils 0.2.4 → 0.2.8

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 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.8](https://github.com/elyukai/ts-utils/compare/v0.2.7...v0.2.8) (2026-02-24)
+
+## [0.2.7](https://github.com/elyukai/ts-utils/compare/v0.2.6...v0.2.7) (2026-02-24)
+
+## [0.2.6](https://github.com/elyukai/ts-utils/compare/v0.2.5...v0.2.6) (2026-02-24)
+
+
+### Features
+
+* add static traverse method to Reader ([693840d](https://github.com/elyukai/ts-utils/commit/693840dde90a0f4d650b0e075610e21a6b1a4318))
+* safe non-empty array map method call ([5a97a69](https://github.com/elyukai/ts-utils/commit/5a97a69f25ac8431d3bc29405b312f750f0e30b9))
+
+## [0.2.5](https://github.com/elyukai/ts-utils/compare/v0.2.4...v0.2.5) (2026-02-22)
+
+
+### Features
+
+* add allSame array function ([8cac98b](https://github.com/elyukai/ts-utils/commit/8cac98bd18e3a4ac7f7acb95b57e55ea031630b4))
+
 ## [0.2.4](https://github.com/elyukai/ts-utils/compare/v0.2.3...v0.2.4) (2026-02-20)
 
 ## [0.2.3](https://github.com/elyukai/ts-utils/compare/v0.2.2...v0.2.3) (2026-02-20)

package/dist/array/filters.d.ts

@@ -16,3 +16,11 @@ export declare const anySame: <T>(arr: T[], equalityCheck?: (a: T, b: T) => bool
  * of found duplicates where the values are the indices of these values.
  */
 export declare const anySameIndices: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => number[][];
+/**
+ * Checks if all elements in the array are the same. An empty array is considered to satisfy this condition.
+ *
+ * @param arr The array to check.
+ * @param equalityCheck An optional function to determine if two elements are considered the same. Defaults to strict shallow equality.
+ * @returns `true` if all elements in the array are the same, otherwise `false`.
+ */
+export declare const allSame: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boolean) => boolean;

package/dist/array/filters.js

@@ -2,6 +2,7 @@
  * Utility functions for filtering arrays.
  * @module
  */
+import { isNotEmpty } from "./nonEmpty.js";
 /**
  * Filters out duplicate values from an array. Objects are not supported, since
  * they don’t provide value equality semantics.
@@ -26,3 +27,11 @@ export const anySameIndices = (arr, equalityCheck = (a, b) => a === b) => arr.re
         : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- The index must exist according to the findIndex above
             acc.with(accIndex, [...acc[accIndex], index]);
 }, []);
+/**
+ * Checks if all elements in the array are the same. An empty array is considered to satisfy this condition.
+ *
+ * @param arr The array to check.
+ * @param equalityCheck An optional function to determine if two elements are considered the same. Defaults to strict shallow equality.
+ * @returns `true` if all elements in the array are the same, otherwise `false`.
+ */
+export const allSame = (arr, equalityCheck = (a, b) => a === b) => isNotEmpty(arr) ? arr.every((item) => equalityCheck(item, arr[0])) : true;

package/dist/reader.d.ts

@@ -50,6 +50,10 @@ export declare class Reader<in R, out T> {
      * Computes the result by providing the required environment.
      */
     run(env: R): T;
+    /**
+     * Apply a function to each value in the array, and return a Reader that produces an array of the results.
+     */
+    static traverse<T, R, U>(values: T[], fn: (value: T) => Reader<R, U>): Reader<R, U[]>;
     /**
      * Evaluate each reader in the array, and collect the results in a single reader instance.
      */

package/dist/reader.js

@@ -2,6 +2,7 @@
  * A simple implementation of the Reader monad, which allows you to write functions that depend on some shared environment.
  * @module
  */
+import { identity } from "./function.js";
 // A simpler wrapper for working with text that is generated based on different contexts, which encapsulates the context and reduces main code clutter. The context is only applied in the end.
 /**
  * The Reader monad represents a computation that depends on some shared environment. It allows you to write functions that can access this environment without having to pass it explicitly as an argument.
@@ -71,11 +72,17 @@ export class Reader {
     run(env) {
         return this.#fn(env);
     }
+    /**
+     * Apply a function to each value in the array, and return a Reader that produces an array of the results.
+     */
+    static traverse(values, fn) {
+        return new Reader((env) => values.map((value) => fn(value).run(env)));
+    }
     /**
      * Evaluate each reader in the array, and collect the results in a single reader instance.
      */
     static sequence(readers) {
-        return new Reader((env) => readers.map((reader) => reader.run(env)));
+        return Reader.traverse(readers, identity);
     }
     /**
      * Transforms a function that returns a Reader into a Reader that produces a function.

package/package.json

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