Add union pipe

Author: fknop

README.md

@@ -32,6 +32,7 @@ You can find the documentations in the [`docs`](./docs) folder.
 * [`uniq`](./docs/array.md#uniq)
 * [`without`](./docs/array.md#without)
 * [`intersection`](./docs/array.md#intersection)
+* [`union`](./docs/array.md#union)
 * [`range`](./docs/array.md#range)
 * [`map`](./docs/array.md#map)
 * [`pluck`](./docs/array.md#pluck)

docs/array.md

@@ -9,6 +9,7 @@
 * [`uniq`](#uniq)
 * [`without`](#without)
 * [`intersection`](#intersection)
+* [`union`](#union)
 * [`range`](#range) 
 * [`map`](#map) 
 * [`pluck`](#pluck)
@@ -188,6 +189,25 @@ import { IntersectionPipe } from 'angular-pipes/src/array/intersection.pipe';
 {{ [{ a: 1 }, { a: 2 }] | deep | intersection: [{ a: 1 }, { a: 3 }] }} <!-- [{a: 1}] -->
 ```
 
+####union 
+
+Returns the union of two collection, works with deep equal.
+
+##### File 
+
+```typescript
+import { UnionPipe } from 'angular-pipes/src/array/union.pipe';
+```
+
+##### Usage 
+
+```html
+{{ [1, 2, 3] | union: [1, 2] }} <!-- [1, 2, 3] -->
+{{ [1, 2] | union: [3, 4] }} <!-- [1, 2, 3, 4] -->
+{{ [{ a: 1 }, { a: 2 }] | union: [{ a: 1 }, { a: 3 }] }} <!-- [{ a: 1 }, { a: 2 }, { a: 1 }, { a: 3 }] (no deep here)-->
+{{ [{ a: 1 }, { a: 2 }] | deep | union: [{ a: 1 }, { a: 3 }] }} <!-- [{ a: 1 }, { a: 2 }, { a: 3 }] -->
+```
+
 ####range
 
 Returns a range of number with a given size (`default: 0`) and start (`default: 1`).

package.json

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

src/array/index.ts

@@ -25,6 +25,7 @@ import { DeepPipe } from './deep.pipe';
 import { ChunkPipe } from './chunk.pipe';
 import { FlattenPipe } from './flatten.pipe';
 import { IntersectionPipe } from './intersection.pipe';
+import { UnionPipe } from './union.pipe';
 
 export * from './empty.pipe';
 export * from './head.pipe';
@@ -51,6 +52,7 @@ export * from './deep.pipe';
 export * from './chunk.pipe';
 export * from './flatten.pipe';
 export * from './intersection.pipe';
+export * from './union.pipe';
 
 
 
@@ -80,7 +82,8 @@ export * from './intersection.pipe';
     ChunkPipe,
     FlattenPipe,
     FirstOrDefaultPipe,
-    IntersectionPipe
+    IntersectionPipe,
+    UnionPipe
   ],
   exports: [
     EmptyPipe,
@@ -107,7 +110,8 @@ export * from './intersection.pipe';
     ChunkPipe,
     FlattenPipe,
     FirstOrDefaultPipe,
-    IntersectionPipe
+    IntersectionPipe,
+    UnionPipe
   ]
 })
 export class NgArrayPipesModule {}

src/array/intersection.pipe.spec.ts

@@ -52,7 +52,7 @@ describe('IntersectionPipe', () => {
         expect(pipe.transform(collection, collection2)).toEqual([]);
     });
 
-    it ('Should return unique values with deep equal', () => {
+    it ('Should return intersection with deep equal', () => {
 
         const collection = [
             { a: 1, b: { c: 2 } },

src/array/union.pipe.spec.ts

@@ -0,0 +1,78 @@
+import { UnionPipe } from './union.pipe';
+import { DeepPipe } from './deep.pipe';
+
+
+describe('UnionPipe', () => {
+    
+    let pipe: UnionPipe;
+    let deepPipe: DeepPipe;
+    
+    beforeEach(() => {
+       pipe = new UnionPipe();
+       deepPipe = new DeepPipe(); 
+    });
+    
+    it('Should return the union', () => {
+       
+       const a = [1, 1, 1, 2, 3, 3, 4, 5];
+       const b = [1, 2];
+       const result = pipe.transform(a, b)
+       expect(result).toEqual([1, 2, 3, 4, 5]); 
+       expect(a).toEqual([1, 1, 1, 2, 3, 3, 4, 5]); // Check integrity
+       expect(b).toEqual([1, 2]); // Check integrity
+    });
+    
+    it('Should return the union #2', () => {
+       
+       const result = pipe.transform([1, 2], [3, 4])
+       expect(result).toEqual([1, 2, 3, 4]); 
+    });
+    
+    it('Should return an empty array', () => {
+       
+       expect(pipe.transform('a')).toEqual([]); 
+       expect(pipe.transform([], 'a')).toEqual([]); 
+       expect(pipe.transform(deepPipe.transform({ a: 1 }), [])).toEqual([]); 
+    });
+
+    
+    it ('Should return the union with no deep equal', () => {
+        
+        const collection = [
+            { a: 1, b: { c: 2 } },
+            { a: 2, b: { c: 3 } },
+            { a: 2, b: { c: 3 } },
+            { a: 1, b: { c: 2 } }
+        ];
+
+        const collection2 = [
+          { a: 1, b: { c: 2 }}
+        ];
+
+        expect(pipe.transform(collection, collection2)).toEqual(collection.concat(collection2));
+    });
+    
+    it ('Should return union with deep equal', () => {
+        
+        const collection = [
+            { a: 1, b: { c: 2 } },
+            { a: 2, b: { c: 3 } },
+            { a: 2, b: { c: 3 } },
+            { a: 1, b: { c: 2 } }
+        ];
+
+        const collection2 = [
+          { a: 1, b: { c: 2 }},
+          { a: 2, b: { c: 3 }},
+          { a: 3, b: { c: 2 }}
+        ];
+        
+        const deep = deepPipe.transform(collection);
+        
+        expect(pipe.transform(deep, collection2)).toEqual([
+          { a: 1, b: { c: 2 } },
+          { a: 2, b: { c: 3 } },
+          { a: 3, b: { c: 2 } }
+        ]);
+    });
+});

src/array/union.pipe.ts

@@ -0,0 +1,29 @@
+import { Pipe, PipeTransform  } from '@angular/core';
+import { isArray, isDeepObject, unwrapDeep, deepIndexOf } from '../utils/utils';
+
+@Pipe({
+  name: 'union'
+})
+export class UnionPipe implements PipeTransform {
+  
+  transform (a?: any, b?: any): any {
+    
+    if ((!isArray(a) && !isDeepObject(a)) || !isArray(b)) {
+      return [];
+    }
+    
+    if (isDeepObject(a)) {
+      const unwrapped = unwrapDeep(a);
+      if (!isArray(unwrapped)) {
+        return [];
+      }
+      
+      return []
+        .concat(unwrapped)
+        .concat(b)
+        .filter((value: any, index: number, input: any[]) => deepIndexOf(input, value) === index);
+    }
+
+    return [].concat(a).concat(b).filter((value: any, index: number, input: any[]) => input.indexOf(value) === index);
+  }
+}