Some updates

- Fixes average method
- Update docs
- Update method class

README.md

@@ -16,7 +16,7 @@ let query = Queryable
  total: Queryable.fromSync(x.items).count() // Here will return number, not Promise<number>
  }
  })
-const asyncData = query.count() // Will return Promise<{area:string, total:number}>
+const asyncData = query.toList() // Will return Promise<{area:string, total:number}>
 asyncData.then(data => {
  console.log(data);
  // [

src/demo/test.ts

@@ -1,6 +1,7 @@
 import { Queryable } from "../implements/queryable";
+const cTable = require('console.table');
 
-let players = new Promise((resolve, reject) => {
+let players = new Promise<{ name, overall, nationId, skills }[]>((resolve, reject) => {
  // skills: attack, stamia, speed, shoot
  console.log('get players...');
  setTimeout(() => {
@@ -36,28 +37,19 @@ let continents = new Promise<{ id, areaName }[]>(resolve => {
  }, 2300);
 })
 
-
 function main() {
- // Just query not execute query
- console.time('querytime');
  let query = Queryable
- .from(nations)
- .join(continents, (x, y) => x.areaId === y.id)
- .groupBy(o => o.y.areaName)
- .select(x => {
- return {
- area: x.key,
- total: Queryable.fromSync(x.items).count()
- }
- })
-
-
- console.timeEnd('querytime');
+ .from(nations)
+ .join(continents, (x, y) => x.areaId === y.id)
+ .groupBy(o => o.y.areaName)
+ .select(x => {
+ return {
+ area: x.key,
+ total: Queryable.fromSync(x.items).count()
+ }
+ })
 
- console.time('executetime');
  const data = query.toList().then(data => {
- console.timeEnd('executetime');
- console.log(data);
  console.table(data);
  });
 }

src/implements/methods.ts

@@ -75,25 +75,25 @@ export class IteratorMethods<T> implements IMethods<T> {
  }
 
  first(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return new FirstClause(iterator).execute(data) as T;
  });
  }
 
  firstOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new FirstClause(iterator).execute(data) || null) as T;
  });
  }
 
  last(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return new LastClause(iterator).execute(data) as T;
  });
  }
 
  lastOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new LastClause(iterator).execute(data) || null) as T;
  });
  }
@@ -106,39 +106,39 @@ export class IteratorMethods<T> implements IMethods<T> {
 
 
  sum<S>(iterator: (entity: T) => S): Promise<number> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new SumClause(iterator).execute(data) || null) as number;
  });
  }
 
  avarage<S>(iterator: (entity: T) => S): Promise<number> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new AvarageClause(iterator).execute(data) || 0) as number;
  });
  }
 
  min<S>(iterator: (entity: T) => S): Promise<number> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new MinClause(iterator).execute(data) || null) as number;
  });
  }
 
  max<S>(iterator: (entity: T) => S): Promise<number> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return (new MaxClause(iterator).execute(data) || null) as number;
  });
  }
 
  single(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  if (!data) throw new Error("Single require source is not null");
  return new SingleClause(iterator).execute(data);
 
  });
  }
 
  singleOrDefault(iterator?: (entity: T) => boolean): Promise<T> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return new SingleClause(iterator).execute(data) || null;
  });
  }
@@ -164,13 +164,13 @@ export class IteratorMethods<T> implements IMethods<T> {
  }
 
  any<T>(iterator: (entity: T) => boolean): Promise<boolean> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return new AnyClause(iterator).execute(data);
  });
  }
 
  contains(entity: T): Promise<boolean> {
- return this.toList().then((data: T[]) => {
+ return this.filterReturn(this.toList(), (data) => {
  return new ContainsClause(entity).execute(data);
  });
  }

src/intefaces/methods.interface.ts

@@ -21,7 +21,7 @@ export interface IMethods<T> {
  sum<S>(iterator: (entity: T) => S): Promise<number>;
  min<S>(iterator: (entity: T) => S): Promise<number>;
  max<S>(iterator: (entity: T) => S): Promise<number>;
- avarage<S>(iterator: (entity: T) => S): Promise<number>;
+ avarage<S>(iterator?: (entity: T) => S): Promise<number>;
  any<T>(iterator: (entity: T) => boolean): Promise<boolean>;
  contains(entity: T): Promise<boolean>;
 

src/methods/average.ts

@@ -9,11 +9,12 @@ export class AvarageClause<T> extends BaseIterator<T> implements IIterator<T> {
  execute(source: any[] | T[]): T[] | T | any {
  if (!source) return 0;
 
- let _result = new SelectClause(this._iterator).execute(source) as number[];
+ let _result = this._iterator
+ ? new SelectClause(this._iterator).execute(source) as number[]
+ : source;
 
  if (!_result) return 0;
-
- if (!Number.isNaN(_result[0])) throw new Error("Avarage operator need type of number");
+ if (Number.isNaN(_result[0])) throw new Error("Avarage operator need type of number");
 
  return (_result.reduce((a, b) => a + b, 0)) / _result.length;
  }