Fixing group by problem

Author: berhalak

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "fromit",
 	"private": false,
-	"version": "2.2.10",
+	"version": "2.2.11",
 	"description": "Typescript linq",
 	"main": "dist/index.js",
 	"module": "dist/fromit.mjs",

src/async.ts

@@ -1,6 +1,6 @@
 
 type Selector<T, M = any> = (item: T, index: number) => PromiseLike<M> | M;
-type Matcher<T> = (item: T) => PromiseLike<boolean> | boolean
+type Matcher<T> = (item: T, index: number) => PromiseLike<boolean> | boolean
 type Property<T> = keyof T;
 const truthy: Matcher<any> = x => !!x;
 type FlatElement<Arr, Depth extends number> = {
@@ -136,15 +136,17 @@ export abstract class AEnumerable<T> implements AsyncIterable<T> {
   }
 
   async find(filter: Matcher<T>) {
+    let index = 0;
     for await (let item of this) {
-      if (filter(item)) return item;
+      if (filter(item, index++)) return item;
     }
     return undefined;
   }
 
   async some(filter: Matcher<T>) {
+    let index = 0;
     for await (let item of this) {
-      if (filter(item)) return true;
+      if (filter(item, index++)) return true;
     }
     return false;
   }
@@ -463,9 +465,11 @@ class Skip<T> extends AEnumerable<T> {
       }
     } else {
       let skip = true;
+      let index = -1;
       for await (let item of this.list) {
+        index++;
         if (skip) {
-          skip = await this._matcher(item);
+          skip = await this._matcher(item, index);
         }
         if (!skip) {
           yield item;
@@ -488,8 +492,10 @@ class Take<T> extends Skip<T> {
         }
       }
     } else {
+      let index = -1;
       for await (let item of this.list) {
-        if (!(await this._matcher(item))) {
+        index++;
+        if (!(await this._matcher(item, index))) {
           return;
         }
         yield item;
@@ -505,8 +511,9 @@ class Filter<T> extends AEnumerable<T> {
   }
 
   async *[Symbol.asyncIterator]() {
+    let index = 0;
     for await (let item of this.list) {
-      if (this.selector(item)) {
+      if (this.selector(item, index++)) {
         yield item;
       }
     }

src/index.spec.ts

@@ -112,6 +112,12 @@ test("skip", async () => {
   expect(from(a).take(2).last()).toBe(2);
 });
 
+test("reverse group", async () => {
+  const a = [3, 4, 1, 2, 5];
+  expect(from(a).sort().reverse().take(2).reverse().toArray()).toStrictEqual([4, 5]);
+  expect(from(a).sort().reverse().take(2).groupBy(x => x).map(x=> x.key).toArray()).toStrictEqual([5, 4]);
+});
+
 test("take", async () => {
   let flag = false;
   function* gen() {

src/index.ts

@@ -1,7 +1,7 @@
 import {AEnumerable, AFrom} from './async';
 
 type Selector<T, M = any> = (value: T, index: number) => M;
-type Matcher<T> = (item: T) => boolean;
+type Matcher<T> = (item: T, index: number) => boolean;
 type Property<T> = keyof T;
 const identity: Matcher<any> = x => !!x;
 type FlatElement<Arr, Depth extends number> = {
@@ -117,15 +117,17 @@ abstract class Enumerable<T> implements Iterable<T> {
   }
 
   find(filter: Matcher<T>) {
+    let index = 0;
     for (let item of this) {
-      if (filter(item)) return item;
+      if (filter(item, index++)) return item;
     }
     return undefined;
   }
 
   some(filter: Matcher<T>) {
+    let index = 0;
     for (let item of this) {
-      if (filter(item)) return true;
+      if (filter(item, index++)) return true;
     }
     return false;
   }
@@ -280,7 +282,7 @@ abstract class Enumerable<T> implements Iterable<T> {
 }
 
 class Group<V, K> extends Enumerable<V> {
-  constructor(public key: K, private buffer: V[]) {
+  constructor(public key: K, private buffer: Enumerable<V>) {
     super();
   }
 
@@ -323,29 +325,18 @@ class GroupedEnumerable<V, K> extends Enumerable<Group<V, K>> {
   }
 
   *[Symbol.iterator](): IterableIterator<Group<V, K>> {
-    let last: K = null;
-    let start = true;
-    let buffer: V[] = [];
-    let index = 0;
-    for (let item of this.list.orderBy(this.selector)) {
-      if (start) {
-        start = false;
-        last = this.selector(item, index++);
-        buffer.push(item);
-        continue;
-      }
-      let current = this.selector(item, index++);
-      if (current !== last) {
-        yield new Group<V, K>(last, buffer);
-        buffer = [item];
-        last = current;
-        continue;
-      }
-      buffer.push(item);
-    }
-    if (buffer.length) {
-      yield new Group<V, K>(last, buffer);
-    }
+    const seen = new Set<K>;
+    let index = -1;
+    for(const item of this.list) {
+      index++;
+      const key = this.selector(item, index);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      yield new Group(key,
+        from(this.list).skip(index)
+        .filter((item, sub) => this.selector(item, index + sub) === key)
+      );
+    }    
   }
 }
 
@@ -429,9 +420,11 @@ class Skip<T> extends Enumerable<T> {
       }
     } else {
       let skip = true;
+      let index = -1;
       for (let item of this.list) {
+        index++;
         if (skip) {
-          skip = this._matcher(item);
+          skip = this._matcher(item, index);
         }
         if (!skip) {
           yield item;
@@ -454,8 +447,10 @@ class Take<T> extends Skip<T> {
         }
       }
     } else {
+      let index = -1;
       for (let item of this.list) {
-        if (!this._matcher(item)) {
+        index++;
+        if (!this._matcher(item, index)) {
           return;
         }
         yield item;
@@ -488,8 +483,9 @@ class Filter<T> extends Enumerable<T> {
   }
 
   *[Symbol.iterator]() {
+    let index = 0;
     for (let item of this.list) {
-      if (this.selector(item)) {
+      if (this.selector(item, index++)) {
         yield item;
       }
     }