@naturalcycles/js-lib 15.49.0 → 15.50.0

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 (let 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 (let 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/dist/types.d.ts

@@ -288,23 +288,17 @@ export declare const _stringMapValues: <T>(map: StringMap<T>) => T[];
  */
 export declare const _stringMapEntries: <T>(map: StringMap<T>) => [k: string, v: T][];
 /**
- * Resolves to a string literal union of the keys of T, meaning they are
- * always keys of T and always strings (never numbers or symbols).
- */
-export type ObjectKey<T> = `${Extract<keyof T, string | number>}`;
-/**
- * Alias of `Object.keys`, but returns keys with a string type that's as
- * narrow as possible.
+ * Alias of `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
  */
-export declare const _objectKeys: <T extends AnyObject>(obj: T) => ObjectKey<T>[];
+export declare const _objectKeys: <T extends AnyObject>(obj: T) => (keyof T)[];
 /**
  * Alias of `Object.entries`, but returns better-typed output.
  *
  * So e.g you can use _objectEntries(obj).map([k, v] => {})
  * and `k` will be `keyof obj` instead of generic `string`.
  */
-export declare const _objectEntries: <T extends AnyObject>(obj: T) => [k: ObjectKey<T>, v: T[ObjectKey<T>]][];
+export declare const _objectEntries: <T extends AnyObject>(obj: T) => [k: keyof T, v: T[keyof T]][];
 export type NullishValue = null | undefined;
 export type FalsyValue = false | '' | 0 | null | undefined;
 /**

package/dist/types.js

@@ -31,8 +31,7 @@ export const _stringMapValues = Object.values;
  */
 export const _stringMapEntries = Object.entries;
 /**
- * Alias of `Object.keys`, but returns keys with a string type that's as
- * narrow as possible.
+ * Alias of `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
  */
 export const _objectKeys = Object.keys;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.49.0",
+  "version": "15.50.0",
   "dependencies": {
     "tslib": "^2",
     "undici": "^7",

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 (let 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 (let 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

@@ -361,17 +361,10 @@ export const _stringMapValues = Object.values as <T>(map: StringMap<T>) => T[]
 export const _stringMapEntries = Object.entries as <T>(map: StringMap<T>) => [k: string, v: T][]
 
 /**
- * Resolves to a string literal union of the keys of T, meaning they are
- * always keys of T and always strings (never numbers or symbols).
- */
-export type ObjectKey<T> = `${Extract<keyof T, string | number>}`
-
-/**
- * Alias of `Object.keys`, but returns keys with a string type that's as
- * narrow as possible.
+ * Alias of `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
  */
-export const _objectKeys = Object.keys as <T extends AnyObject>(obj: T) => ObjectKey<T>[]
+export const _objectKeys = Object.keys as <T extends AnyObject>(obj: T) => (keyof T)[]
 
 /**
  * Alias of `Object.entries`, but returns better-typed output.
@@ -381,7 +374,7 @@ export const _objectKeys = Object.keys as <T extends AnyObject>(obj: T) => Objec
  */
 export const _objectEntries = Object.entries as <T extends AnyObject>(
   obj: T,
-) => [k: ObjectKey<T>, v: T[ObjectKey<T>]][]
+) => [k: keyof T, v: T[keyof T]][]
 
 export type NullishValue = null | undefined
 export type FalsyValue = false | '' | 0 | null | undefined
@@ -499,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`.