@naturalcycles/js-lib 15.49.1 → 15.50.1

package/dist/array/array.util.d.ts

@@ -197,6 +197,10 @@ export declare function _lastOrUndefined<T>(array: readonly T[]): T | undefined;
  * Throws if array is empty.
  */
 export declare function _first<T>(array: readonly T[]): T;
+/**
+ * Returns first item of the array (or undefined if array is empty).
+ */
+export declare function _firstOrUndefined<T>(array: readonly T[]): T | undefined;
 export declare function _minOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined;
 /**
  * Filters out nullish values (undefined and null).
@@ -209,6 +213,10 @@ export declare function _maxOrUndefined<T>(array: readonly T[]): NonNullable<T>
 export declare function _max<T>(array: readonly T[]): NonNullable<T>;
 export declare function _maxBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T;
 export declare function _minBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T;
+export declare function _minMax<T>(array: readonly T[]): [min: NonNullable<T>, max: NonNullable<T>];
+export declare function _minMaxOrUndefined<T>(array: readonly T[]): [min: NonNullable<T>, max: NonNullable<T>] | undefined;
+export declare function _minMaxBy<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): [min: NonNullable<T>, max: NonNullable<T>];
+export declare function _minMaxByOrUndefined<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): [min: NonNullable<T>, max: NonNullable<T>] | undefined;
 export declare function _maxByOrUndefined<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
 export declare function _minByOrUndefined<T>(array: readonly T[], mapper: Mapper<T, number | string | undefined>): T | undefined;
 export declare function _zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): [T1, T2][];

package/dist/array/array.util.js

@@ -363,6 +363,12 @@ export function _first(array) {
         throw new Error('_first called on empty array');
     return array[0];
 }
+/**
+ * Returns first item of the array (or undefined if array is empty).
+ */
+export function _firstOrUndefined(array) {
+    return array[0];
+}
 export function _minOrUndefined(array) {
     let min;
     for (const item of array) {
@@ -411,6 +417,75 @@ export function _minBy(array, mapper) {
     _assert(min !== undefined, '_minBy returned undefined');
     return min;
 }
+export function _minMax(array) {
+    if (!array.length)
+        throw new Error('_minMax called on empty array');
+    const result = _minMaxOrUndefined(array);
+    _assert(result !== undefined, '_minBy returned undefined');
+    return result;
+}
+export function _minMaxOrUndefined(array) {
+    if (!array.length)
+        return;
+    let min;
+    let max;
+    for (const item of array) {
+        if (item === undefined || item === null)
+            continue;
+        if (min === undefined)
+            min = item;
+        if (max === undefined)
+            max = item;
+        if (item < min)
+            min = item;
+        if (item > max)
+            max = item;
+    }
+    if (min === undefined || max === undefined || min === null || max === null)
+        return;
+    return [min, max];
+}
+export function _minMaxBy(array, mapper) {
+    if (!array.length)
+        throw new Error('_minMaxBy called on empty array');
+    const result = _minMaxByOrUndefined(array, mapper);
+    _assert(result !== undefined, '_minMaxBy returned undefined');
+    return result;
+}
+export function _minMaxByOrUndefined(array, mapper) {
+    if (!array.length)
+        return;
+    let min;
+    let minItem;
+    let max;
+    let maxItem;
+    for (const item of array) {
+        if (item === undefined || item === null)
+            continue;
+        const value = mapper(item);
+        if (!value)
+            continue;
+        if (min === undefined) {
+            min = value;
+            minItem = item;
+        }
+        if (max === undefined) {
+            max = value;
+            maxItem = item;
+        }
+        if (value < min) {
+            min = value;
+            minItem = item;
+        }
+        if (value > max) {
+            max = value;
+            maxItem = item;
+        }
+    }
+    if (minItem === undefined || maxItem === undefined || minItem === null || maxItem === null)
+        return;
+    return [minItem, maxItem];
+}
 // todo: looks like it _maxByOrUndefined/_minByOrUndefined can be DRYer
 export function _maxByOrUndefined(array, mapper) {
     if (!array.length)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.49.1",
+  "version": "15.50.1",
   "dependencies": {
     "tslib": "^2",
     "undici": "^7",
@@ -13,7 +13,7 @@
     "@types/semver": "^7",
     "crypto-js": "^4",
     "dayjs": "^1",
-    "@naturalcycles/dev-lib": "18.4.2"
+    "@naturalcycles/dev-lib": "20.12.10"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/array/array.util.ts

@@ -424,6 +424,13 @@ export function _first<T>(array: readonly T[]): T {
   return array[0]!
 }
 
+/**
+ * Returns first item of the array (or undefined if array is empty).
+ */
+export function _firstOrUndefined<T>(array: readonly T[]): T | undefined {
+  return array[0]
+}
+
 export function _minOrUndefined<T>(array: readonly T[]): NonNullable<T> | undefined {
   let min: NonNullable<T> | undefined
   for (const item of array) {
@@ -476,6 +483,87 @@ export function _minBy<T>(array: readonly T[], mapper: Mapper<T, number | string
   return min
 }
 
+export function _minMax<T>(array: readonly T[]): [min: NonNullable<T>, max: NonNullable<T>] {
+  if (!array.length) throw new Error('_minMax called on empty array')
+  const result = _minMaxOrUndefined(array)
+  _assert(result !== undefined, '_minBy returned undefined')
+  return result
+}
+
+export function _minMaxOrUndefined<T>(
+  array: readonly T[],
+): [min: NonNullable<T>, max: NonNullable<T>] | undefined {
+  if (!array.length) return
+
+  let min: T | undefined
+  let max: T | undefined
+
+  for (const item of array) {
+    if (item === undefined || item === null) continue
+    if (min === undefined) min = item
+    if (max === undefined) max = item
+    if (item < min) min = item
+    if (item > max) max = item
+  }
+
+  if (min === undefined || max === undefined || min === null || max === null) return
+
+  return [min, max]
+}
+
+export function _minMaxBy<T>(
+  array: readonly T[],
+  mapper: Mapper<T, number | string | undefined>,
+): [min: NonNullable<T>, max: NonNullable<T>] {
+  if (!array.length) throw new Error('_minMaxBy called on empty array')
+  const result = _minMaxByOrUndefined(array, mapper)
+  _assert(result !== undefined, '_minMaxBy returned undefined')
+  return result
+}
+
+export function _minMaxByOrUndefined<T>(
+  array: readonly T[],
+  mapper: Mapper<T, number | string | undefined>,
+): [min: NonNullable<T>, max: NonNullable<T>] | undefined {
+  if (!array.length) return
+
+  let min: ReturnType<typeof mapper> | undefined
+  let minItem: T | undefined
+  let max: ReturnType<typeof mapper> | undefined
+  let maxItem: T | undefined
+
+  for (const item of array) {
+    if (item === undefined || item === null) continue
+
+    const value = mapper(item)
+    if (!value) continue
+
+    if (min === undefined) {
+      min = value
+      minItem = item
+    }
+
+    if (max === undefined) {
+      max = value
+      maxItem = item
+    }
+
+    if (value < min) {
+      min = value
+      minItem = item
+    }
+
+    if (value > max) {
+      max = value
+      maxItem = item
+    }
+  }
+
+  if (minItem === undefined || maxItem === undefined || minItem === null || maxItem === null) return
+
+  return [minItem, maxItem]
+}
+
 // todo: looks like it _maxByOrUndefined/_minByOrUndefined can be DRYer
 
 export function _maxByOrUndefined<T>(

package/src/http/fetcher.model.ts

@@ -14,7 +14,8 @@ import type {
 import type { HttpMethod, HttpStatusFamily } from './http.model.js'
 
 export interface FetcherNormalizedCfg
-  extends Required<Omit<FetcherCfg, 'dispatcher'>>,
+  extends
+    Required<Omit<FetcherCfg, 'dispatcher'>>,
     Omit<
       FetcherRequest,
       | 'started'
@@ -148,8 +149,10 @@ export interface FetcherRetryOptions {
   timeoutMultiplier: number
 }
 
-export interface FetcherRequest
-  extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
+export interface FetcherRequest extends Omit<
+  FetcherOptions,
+  'method' | 'headers' | 'baseUrl' | 'url'
+> {
   /**
    * inputUrl is only the part that was passed in the request,
    * without baseUrl or searchParams.

package/src/types.ts

@@ -492,8 +492,10 @@ export type ReadonlyDeep<T> = T extends Primitive | ((...args: any[]) => unknown
 /**
  Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
  */
-interface ReadonlyMapDeep<KeyType, ValueType>
-  extends ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>> {}
+interface ReadonlyMapDeep<KeyType, ValueType> extends ReadonlyMap<
+  ReadonlyDeep<KeyType>,
+  ReadonlyDeep<ValueType>
+> {}
 
 /**
  Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.