feat: add min and max

src/Sequence.ts

@@ -150,10 +150,38 @@ export class SequenceImpl<TItem> implements Iterable<TItem>, Sequence<TItem> {
     return items.length === 0 ? undefined : items[items.length - 1];
   }
 
+  max<TItem>(): TItem | undefined {
+    let result: any | undefined = undefined;
+
+    for (const item of this._iterable) {
+      if (result === undefined) {
+        result = item as any;
+      } else if (item > result) {
+        result = item;
+      }
+    }
+
+    return result;
+  }
+
   map<TResultItem>(mapFn: MapFn<TItem, TResultItem>): Sequence<TResultItem> {
     return this._sequenceFromGenerator<TResultItem>(map, [mapFn]);
   }
 
+  min<TItem>(): TItem | undefined {
+    let result: any | undefined = undefined;
+
+    for (const item of this._iterable) {
+      if (result === undefined) {
+        result = item as any;
+      } else if (item < result) {
+        result = item;
+      }
+    }
+
+    return result;
+  }
+
   pick<TKeys extends keyof TItem>(
     ...keys: TKeys[]
   ): Sequence<{ [P in TKeys]: TItem[P] }> {

src/types.ts

@@ -284,6 +284,16 @@ export interface Sequence<TItem> extends Iterable<TItem> {
    * ```
    */
   last(): TItem | undefined;
+  /**
+   * Returns the maximum value in the sequence. `undefined` is returned if the squence is empty.
+   *
+   * @example
+   * ```typescript
+   * // Returns 3
+   * from([1, 2, 3]).max();
+   * ```
+   */
+  max<TItem>(): TItem | undefined;
   /**
    * Maps the sequence to a new sequence where each item is converted
    * to a new value using the given mapper function.
@@ -295,6 +305,16 @@ export interface Sequence<TItem> extends Iterable<TItem> {
    * ```
    */
   map<TResultItem>(mapFn: MapFn<TItem, TResultItem>): Sequence<TResultItem>;
+  /**
+   * Returns the minimum value in the sequence. `undefined` is returned if the squence is empty.
+   *
+   * @example
+   * ```typescript
+   * // Returns 1
+   * from([1, 2, 3]).min();
+   * ```
+   */
+  min<TItem>(): TItem | undefined;
   /**
    * Maps each item in the sequence to an object composed of the picked
    * object properties.

test/fromfrom.test.ts

@@ -440,6 +440,21 @@ describe("fromfrom", () => {
     });
   });
 
+  describe("max", () => {
+    it("returns the maximum value for numbers", () => {
+      expect(from([1, 2, 3]).max()).toEqual(3);
+      expect(from([3, 2, 1]).max()).toEqual(3);
+    });
+
+    it("returns maximum value for string", () => {
+      expect(from(["1", "2", "3"]).max()).toEqual("3");
+    });
+
+    it("returns undefined if sequence is empty", () => {
+      expect(from([]).max()).toBeUndefined();
+    });
+  });
+
   describe("map", () => {
     let mapper: jest.Mock;
 
@@ -486,6 +501,21 @@ describe("fromfrom", () => {
     });
   });
 
+  describe("min", () => {
+    it("returns the minimum value for numbers", () => {
+      expect(from([1, 2, 3]).min()).toEqual(1);
+      expect(from([3, 2, 1]).min()).toEqual(1);
+    });
+
+    it("returns minimum value for string", () => {
+      expect(from(["1", "2", "3"]).min()).toEqual("1");
+    });
+
+    it("returns undefined if sequence is empty", () => {
+      expect(from([]).min()).toBeUndefined();
+    });
+  });
+
   describe("pick", () => {
     const user = Object.freeze({
       name: {