Merge pull request 'develop' (#2) from develop into main

Reviewed-on: #2

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infendro/collection",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "scripts": {
     "build": "tsc"
   },

src/collection.ts

@@ -14,6 +14,9 @@ import {count} from "./collection/count";
 import {distinct} from "./collection/distinct";
 import {distinctBy} from "./collection/distinctBy";
 import {drop} from "./collection/drop";
+import {dropLast} from "./collection/dropLast";
+import {dropLastUntil} from "./collection/dropLastUntil";
+import {dropLastWhile} from "./collection/dropLastWhile";
 import {dropUntil} from "./collection/dropUntil";
 import {dropWhile} from "./collection/dropWhile";
 import {filter} from "./collection/filter";
@@ -69,24 +72,27 @@ import {sortedWith} from "./collection/sortedWith";
 import {sum} from "./collection/sum";
 import {sumBy} from "./collection/sumBy";
 import {take} from "./collection/take";
+import {takeLast} from "./collection/takeLast";
+import {takeLastUntil} from "./collection/takeLastUntil";
+import {takeLastWhile} from "./collection/takeLastWhile";
 import {takeUntil} from "./collection/takeUntil";
 import {takeWhile} from "./collection/takeWhile";
 import {toArray} from "./collection/toArray";
 import {toMap} from "./collection/toMap";
+import {Key, Object, toObject} from "./collection/toObject";
 import {toSet} from "./collection/toSet";
 import {unzip} from "./collection/unzip";
 import {windowed} from "./collection/windowed";
 import {withIndex} from "./collection/withIndex";
 import {zip} from "./collection/zip";
-import {Key, Object, toObject} from "./collection/toObject";
 
 export type Collection<T> = {
     [Symbol.iterator](): Iterator<T>
 
-    toObject<K extends Key, V>(this: Collection<[K, V]>): Object<K, V | undefined>
     toArray(): T[]
     toSet(): Set<T>
     toMap<K, V>(this: Collection<[K, V]>): Map<K, V>
+    toObject<K extends Key, V>(this: Collection<[K, V]>): Object<K, V>
 
     onEach(action: (it: T) => void): Collection<T>
     forEach(action: (it: T) => void): void
@@ -157,9 +163,15 @@ export type Collection<T> = {
     drop(count: number): Collection<T>
     dropWhile(predicate: (it: T) => boolean): Collection<T>
     dropUntil(predicate: (it: T) => boolean): Collection<T>
+    dropLast(count: number): Collection<T>
+    dropLastWhile(predicate: (it: T) => boolean): Collection<T>
+    dropLastUntil(predicate: (it: T) => boolean): Collection<T>
     take(count: number): Collection<T>
     takeWhile(predicate: (it: T) => boolean): Collection<T>
     takeUntil(predicate: (it: T) => boolean): Collection<T>
+    takeLast(count: number): Collection<T>
+    takeLastWhile(predicate: (it: T) => boolean): Collection<T>
+    takeLastUntil(predicate: (it: T) => boolean): Collection<T>
     slice(start: number, end?: number): Collection<T>
 
     map<R>(transform: (it: T) => R): Collection<R>
@@ -192,9 +204,6 @@ function wrap<T>(value: T[]): Collection<T> {
         [Symbol.iterator]() {
             return value[Symbol.iterator]();
         },
-        toObject<K extends Key, V>() {
-            return toObject(value as [K, V][]);
-        },
         toArray() {
             return toArray(value);
         },
@@ -204,6 +213,9 @@ function wrap<T>(value: T[]): Collection<T> {
         toMap<K, V>() {
             return toMap(value as [K, V][]);
         },
+        toObject<K extends Key, V>() {
+            return toObject(value as [K, V][]);
+        },
         onEach(action) {
             return wrap(onEach(value, action));
         },
@@ -375,6 +387,15 @@ function wrap<T>(value: T[]): Collection<T> {
         dropUntil(predicate) {
             return wrap(dropUntil(value, predicate));
         },
+        dropLast(count) {
+            return wrap(dropLast(value, count));
+        },
+        dropLastWhile(predicate) {
+            return wrap(dropLastWhile(value, predicate));
+        },
+        dropLastUntil(predicate) {
+            return wrap(dropLastUntil(value, predicate));
+        },
         take(count) {
             return wrap(take(value, count));
         },
@@ -384,6 +405,15 @@ function wrap<T>(value: T[]): Collection<T> {
         takeUntil(predicate) {
             return wrap(takeUntil(value, predicate));
         },
+        takeLast(count) {
+            return wrap(takeLast(value, count));
+        },
+        takeLastWhile(predicate) {
+            return wrap(takeLastWhile(value, predicate));
+        },
+        takeLastUntil(predicate) {
+            return wrap(takeLastUntil(value, predicate));
+        },
         slice(start, end) {
             return wrap(slice(value, start, end));
         },

src/collection/dropLast.ts

@@ -0,0 +1,10 @@
+import {error} from "../util/error";
+
+export function dropLast<T>(value: T[], count: number): T[] {
+    if (count < 0) error();
+    const result: T[] = [];
+    for (let i = 0; i < (value.length - count); i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/dropLastUntil.ts

@@ -0,0 +1,11 @@
+export function dropLastUntil<T>(value: T[], predicate: (it: T) => boolean): T[] {
+    let index = value.length - 1;
+    while (index >= 0 && !predicate(value[index])) {
+        index--;
+    }
+    const result: T[] = [];
+    for (let i = 0; i <= index; i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/dropLastWhile.ts

@@ -0,0 +1,11 @@
+export function dropLastWhile<T>(value: T[], predicate: (it: T) => boolean): T[] {
+    let index = value.length - 1;
+    while (index >= 0 && predicate(value[index])) {
+        index--;
+    }
+    const result: T[] = [];
+    for (let i = 0; i <= index; i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/max.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function max(value: number[]): number {
     if (value.length === 0) error();
     let max = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (it > max) max = it;
     }
     return max;

src/collection/maxBy.ts

@@ -4,8 +4,8 @@ export function maxBy<T>(value: T[], transform: (it: T) => number): T {
     if (value.length === 0) error();
     let maxIt = value[0];
     let maxVal = transform(maxIt);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val > maxVal) {
             maxIt = it;

src/collection/maxByOrNull.ts

@@ -2,8 +2,8 @@ export function maxByOrNull<T>(value: T[], transform: (it: T) => number): T | nu
     if (value.length === 0) return null;
     let maxIt = value[0];
     let maxVal = transform(maxIt);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val > maxVal) {
             maxIt = it;

src/collection/maxOf.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function maxOf<T>(value: T[], transform: (it: T) => number): number {
     if (value.length === 0) error();
     let max = transform(value[0]);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val > max) max = val;
     }

src/collection/maxOfOrNull.ts

@@ -1,8 +1,8 @@
 export function maxOfOrNull<T>(value: T[], transform: (it: T) => number): number | null {
     if (value.length === 0) return null;
     let max = transform(value[0]);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val > max) max = val;
     }

src/collection/maxOrNull.ts

@@ -1,8 +1,8 @@
 export function maxOrNull(value: number[]): number | null {
     if (value.length === 0) return null;
     let max = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (it > max) max = it;
     }
     return max;

src/collection/maxWith.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function maxWith<T>(value: T[], compare: (a: T, b: T) => number): T {
     if (value.length === 0) error();
     let max = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (compare(it, max) > 0) max = it;
     }
     return max;

src/collection/maxWithOrNull.ts

@@ -1,8 +1,8 @@
 export function maxWithOrNull<T>(value: T[], compare: (a: T, b: T) => number): T | null {
     if (value.length === 0) return null;
     let max = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (compare(it, max) > 0) max = it;
     }
     return max;

src/collection/min.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function min(value: number[]): number {
     if (value.length === 0) error();
     let min = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (it < min) min = it;
     }
     return min;

src/collection/minBy.ts

@@ -4,8 +4,8 @@ export function minBy<T>(value: T[], transform: (it: T) => number): T {
     if (value.length === 0) error();
     let minIt = value[0];
     let minVal = transform(minIt);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val < minVal) {
             minIt = it;

src/collection/minByOrNull.ts

@@ -2,8 +2,8 @@ export function minByOrNull<T>(value: T[], transform: (it: T) => number): T | nu
     if (value.length === 0) return null;
     let minIt = value[0];
     let minVal = transform(minIt);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val < minVal) {
             minIt = it;

src/collection/minOf.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function minOf<T>(value: T[], transform: (it: T) => number): number {
     if (value.length === 0) error();
     let min = transform(value[0]);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val < min) min = val;
     }

src/collection/minOfOrNull.ts

@@ -1,8 +1,8 @@
 export function minOfOrNull<T>(value: T[], transform: (it: T) => number): number | null {
     if (value.length === 0) return null;
     let min = transform(value[0]);
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         const val = transform(it);
         if (val < min) min = val;
     }

src/collection/minOrNull.ts

@@ -1,8 +1,8 @@
 export function minOrNull(value: number[]): number | null {
     if (value.length === 0) return null;
     let min = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (it < min) min = it;
     }
     return min;

src/collection/minWith.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function minWith<T>(value: T[], compare: (a: T, b: T) => number): T {
     if (value.length === 0) error();
     let min = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (compare(it, min) < 0) min = it;
     }
     return min;

src/collection/minWithOrNull.ts

@@ -1,8 +1,8 @@
 export function minWithOrNull<T>(value: T[], compare: (a: T, b: T) => number): T | null {
     if (value.length === 0) return null;
     let min = value[0];
-    for (let index = 1; index < value.length; index++) {
-        const it = value[index];
+    for (let i = 1; i < value.length; i++) {
+        const it = value[i];
         if (compare(it, min) < 0) min = it;
     }
     return min;

src/collection/reduce.ts

@@ -3,8 +3,8 @@ import {error} from "../util/error";
 export function reduce<T>(value: T[], accumulate: (acc: T, it: T) => T): T {
     if (value.length === 0) error();
     let acc = value[0];
-    for (let index = 1; index < value.length; index++) {
-        acc = accumulate(acc, value[index]);
+    for (let i = 1; i < value.length; i++) {
+        acc = accumulate(acc, value[i]);
     }
     return acc;
 }

src/collection/reduceOrNull.ts

@@ -1,8 +1,8 @@
 export function reduceOrNull<T>(value: T[], accumulate: (acc: T, it: T) => T): T | null {
     if (value.length === 0) return null;
     let acc = value[0];
-    for (let index = 1; index < value.length; index++) {
-        acc = accumulate(acc, value[index]);
+    for (let i = 1; i < value.length; i++) {
+        acc = accumulate(acc, value[i]);
     }
     return acc;
 }

src/collection/slice.ts

@@ -7,9 +7,8 @@ export function slice<T>(value: T[], start: number, end?: number): T[] {
         if (start > end) error();
     }
     const result: T[] = [];
-    const limit = end ?? value.length;
-    for (let index = start; index < limit; index++) {
-        result.push(value[index]);
+    for (let i = start; i < (end ?? value.length); i++) {
+        result.push(value[i]);
     }
     return result;
 }

src/collection/take.ts

@@ -3,9 +3,9 @@ import {error} from "../util/error";
 export function take<T>(value: T[], count: number): T[] {
     if (count < 0) error();
     const result: T[] = [];
-    const limit = Math.min(count, value.length);
-    for (let index = 0; index < limit; index++) {
-        result.push(value[index]);
+    const index = Math.min(count, value.length);
+    for (let i = 0; i < index; i++) {
+        result.push(value[i]);
     }
     return result;
 }

src/collection/takeLast.ts

@@ -0,0 +1,11 @@
+import {error} from "../util/error";
+
+export function takeLast<T>(value: T[], count: number): T[] {
+    if (count < 0) error();
+    const result: T[] = [];
+    const index = Math.max(0, value.length - count);
+    for (let i = index; i < value.length; i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/takeLastUntil.ts

@@ -0,0 +1,11 @@
+export function takeLastUntil<T>(value: T[], predicate: (it: T) => boolean): T[] {
+    let index = value.length - 1;
+    while (index >= 0 && !predicate(value[index])) {
+        index--;
+    }
+    const result: T[] = [];
+    for (let i = index + 1; i < value.length; i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/takeLastWhile.ts

@@ -0,0 +1,11 @@
+export function takeLastWhile<T>(value: T[], predicate: (it: T) => boolean): T[] {
+    let index = value.length - 1;
+    while (index >= 0 && predicate(value[index])) {
+        index--;
+    }
+    const result: T[] = [];
+    for (let i = index + 1; i < value.length; i++) {
+        result.push(value[i]);
+    }
+    return result;
+}

src/collection/toObject.ts

@@ -1,6 +1,6 @@
 export type Key = keyof any
-export type Object<K extends Key, V> = { [key in K]: V }
+export type Object<K extends Key, V> = { [key in K]?: V }
 
-export function toObject<K extends Key, V>(value: [K, V][]): Object<K, V | undefined> {
-    return Object.fromEntries(value) as Object<K, V | undefined>;
+export function toObject<K extends Key, V>(value: [K, V][]): Object<K, V> {
+    return Object.fromEntries(value) as Object<K, V>;
 }