takeUntil and takeWhile pipes

Author: fknop

CHANGELOG.md

@@ -1,3 +1,16 @@
+# 6.3.0 
+
+## New pipes 
+
+* [`takeWhile`](./docs/array.md#takeWhile)
+* [`takeUntil`](./docs/array.md#takeUntil)
+
+# 6.2.0
+
+## New pipes 
+
+* [`union`](./docs/array.md#union)
+
 # 6.1.0
 
 ## New pipes 

README.md

@@ -45,6 +45,8 @@ You can find the documentations in the [`docs`](./docs) folder.
 * [`every`](./docs/array.md#every)
 * [`shuffle`](./docs/array.md#shuffle)
 * [`take`](./docs/array.md#take)
+* [`takeUntil`](./docs/array.md#takeuntil)
+* [`takeWhile`](./docs/array.md#takewhile)
 * [`drop`](./docs/array.md#drop)
 * [`deep`](./docs/array.md#deep)
 * [`chunk`](./docs/array.md#chunk)

docs/array.md

@@ -22,6 +22,8 @@
 * [`every`](#every)
 * [`shuffle`](#shuffle)
 * [`take`](#take)
+* [`takeUntil`](#takeuntil)
+* [`takeWhile`](#takewhile)
 * [`drop`](#drop)
 * [`deep`](#deep)
 * [`chunk`](#chunk)
@@ -556,6 +558,52 @@ import { TakePipe } from 'angular-pipes/src/array/take.pipe';
 {{ [1, 2, 3, 4] | take: 2 }} <!-- [1, 2] -->
 ```
 
+
+####takeuntil
+
+Take until the condition is met.
+
+##### File
+
+```typescript
+import { TakeUntilPipe } from 'angular-pipes/src/array/take-until.pipe';
+```
+
+##### Usage
+
+```typescript
+function predicate (item: any) {
+  return item >= 4;
+}
+```
+
+```html
+{{ [1, 2, 3, 4] | takeUntil: predicate }} <!-- [1, 2, 3] -->
+```
+
+####takewhile
+
+Take while the condition is met.
+
+##### File
+
+```typescript
+import { TakeWhilePipe } from 'angular-pipes/src/array/take-while.pipe';
+```
+
+##### Usage
+
+```typescript
+function predicate (item: any) {
+  return item < 4;
+}
+```
+
+```html
+{{ [1, 2, 3, 4] | takeWhile }} <!-- [1, 2, 3] -->
+```
+
+
 ####drop
 
 Drop the last `n` items of an array.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-pipes",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Angular pipes library",
   "main": "src/index.js",
   "jsnext:main": "esm/index.js",

src/array/every.pipe.ts

@@ -1,12 +1,12 @@
 import { Pipe, PipeTransform  } from '@angular/core';
-import { every } from '../utils/utils';
+import { every, CollectionPredicate } from '../utils/utils';
 
 @Pipe({
   name: 'every'
 })
 export class EveryPipe implements PipeTransform {
 
-  transform (input: any, predicate: Function): any {
+  transform (input: any, predicate: CollectionPredicate): any {
 
     return every(input, predicate);
   }

src/array/index.ts

@@ -26,6 +26,8 @@ import { ChunkPipe } from './chunk.pipe';
 import { FlattenPipe } from './flatten.pipe';
 import { IntersectionPipe } from './intersection.pipe';
 import { UnionPipe } from './union.pipe';
+import { TakeWhilePipe } from './take-while.pipe';
+import { TakeUntilPipe } from './take-until.pipe';
 
 export * from './empty.pipe';
 export * from './head.pipe';
@@ -53,7 +55,8 @@ export * from './chunk.pipe';
 export * from './flatten.pipe';
 export * from './intersection.pipe';
 export * from './union.pipe';
-
+export * from './take-while.pipe';
+export * from './take-until.pipe';
 
 
 @NgModule({
@@ -83,7 +86,9 @@ export * from './union.pipe';
     FlattenPipe,
     FirstOrDefaultPipe,
     IntersectionPipe,
-    UnionPipe
+    UnionPipe,
+    TakeWhilePipe,
+    TakeUntilPipe
   ],
   exports: [
     EmptyPipe,
@@ -111,7 +116,9 @@ export * from './union.pipe';
     FlattenPipe,
     FirstOrDefaultPipe,
     IntersectionPipe,
-    UnionPipe
+    UnionPipe,
+    TakeWhilePipe,
+    TakeUntilPipe
   ]
 })
 export class NgArrayPipesModule {}

src/array/take-until.pipe.spec.ts

@@ -0,0 +1,41 @@
+import { TakeUntilPipe } from './take-until.pipe';
+
+
+describe('TakeUntilPipe', () => {
+    
+    let pipe: TakeUntilPipe;
+    
+    beforeEach(() => {
+       pipe = new TakeUntilPipe(); 
+    });
+    
+    it ('Should return until the condition is met', () => {
+      const predicate = (item) => item === 1;
+
+      expect(pipe.transform([2, 3, 4, 5, 1, 7, 8], predicate)).toEqual([2, 3, 4, 5]);
+    });
+
+      it ('Should return until the condition is met #2', () => {
+      const predicate = (item) => item === 1;
+
+      expect(pipe.transform([2, 3, 4, 5, 7, 8], predicate)).toEqual([2, 3, 4, 5, 7, 8]);
+    });
+
+
+    it('Should return the objects until a is 5', () => {
+       
+       const predicate = (item: any) => item.a === 4;
+
+       const array = [{a:2}, {a:3}, {a:5}, {a:4}, {a:1}];
+       
+       expect(pipe.transform(array, predicate)).toEqual([{a:2}, {a:3}, {a:5}]);
+    });
+    
+    it('Should return the input', () => {
+        expect(pipe.transform([1])).toEqual([1]);
+    });
+    
+    it('Should return the value unchanged', () => {
+       expect(pipe.transform('a', null)).toEqual('a'); 
+    });
+});

src/array/take-until.pipe.ts

@@ -0,0 +1,17 @@
+import { Pipe, PipeTransform  } from '@angular/core';
+import { isArray, takeUntil, CollectionPredicate, isNil } from '../utils/utils';
+
+@Pipe({
+  name: 'takeUntil'
+})
+export class TakeUntilPipe implements PipeTransform {
+  
+  transform (input: any, predicate?: CollectionPredicate): any {
+    
+    if (!isArray(input) || isNil(predicate)) {
+      return input;
+    }
+    
+    return takeUntil(input, predicate);
+  }
+}

src/array/take-while.pipe.ts

@@ -0,0 +1,17 @@
+import { Pipe, PipeTransform  } from '@angular/core';
+import { isArray, takeWhile, CollectionPredicate, isNil } from '../utils/utils';
+
+@Pipe({
+  name: 'takeWhile'
+})
+export class TakeWhilePipe implements PipeTransform {
+  
+  transform (input: any, predicate?: CollectionPredicate): any {
+    
+    if (!isArray(input) || isNil(predicate)) {
+      return input;
+    }
+    
+    return takeWhile(input, predicate);
+  }
+}

src/array/take-while.spec.ts

@@ -0,0 +1,45 @@
+import { TakeWhilePipe } from './take-while.pipe';
+
+
+describe('TakeWhilePipe', () => {
+    
+    let pipe: TakeWhilePipe;
+    
+    beforeEach(() => {
+       pipe = new TakeWhilePipe(); 
+    });
+    
+    it ('Should return while the condition is met', () => {
+
+      const predicate = (item) => item < 4;
+
+      expect(pipe.transform([1, 2, 3, 4, 1, 5], predicate)).toEqual([1, 2, 3]);
+    });
+
+      it ('Should return while the condition is met #2', () => {
+
+      const predicate = (item) => item < 6;
+
+      expect(pipe.transform([1, 2, 3, 4, 5], predicate)).toEqual([1, 2, 3, 4, 5]);
+    });
+
+
+    it('Should return the objects while the condition is met', () => {
+       
+       const predicate = (item: any) => item.a < 5;
+
+       const array = [{a:2}, {a:3}, {a:5}, {a:4}, {a:1}];
+       
+       expect(pipe.transform(array, predicate)).toEqual([{a:2}, {a:3}]);
+    });
+
+    
+    
+    it('Should return the input', () => {
+        expect(pipe.transform([1])).toEqual([1]);
+    });
+    
+    it('Should return the value unchanged', () => {
+       expect(pipe.transform('a', null)).toEqual('a'); 
+    });
+});