Bytes pipe 2.0

Author: fknop

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 6.5.0
+
+## New feature 
+
+* Byte pipes 2.0 [`bytes`](./docs/math.md#bytes)
+  + The maximum unit is now the terabyte
+  + You can now specify a base unit for the conversion (B, KB, MB, GB, TB)
+
 # 6.4.0 
 
 ## New pipes 

docs/math.md

@@ -28,7 +28,9 @@ import { BytesPipe } from 'angular-pipes/src/math/bytes.pipe';
 {{ 150 | bytes }} <!-- 150 B -->
 {{ 1024 | bytes }} <!-- 1 KB -->
 {{ 1048576 | bytes }} <!-- 1 MB -->
+{{ 1024 | bytes: 0 : 'KB' }} <!-- 1 MB -->
 {{ 1073741824 | bytes }} <!-- 1 GB -->
+{{ 1099511627776 | bytes }} <!-- 1 TB -->
 ```
 
 ##### Todo 

package.json

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

src/math/bytes.pipe.spec.ts

@@ -36,13 +36,25 @@ describe('BytesPipe', () => {
         const result = pipe.transform(1024, 0);
         expect(result).toEqual('1 KB');
     });
+
+    it('Should return 1 KB #2', () => {
+       
+        const result = pipe.transform(1, 0, 'KB');
+        expect(result).toEqual('1 KB');
+    });
 
     it('Should return 890 KB', () => {
 
         const kb = 1024 * 890;
         const result = pipe.transform(kb, 0);
         expect(result).toEqual('890 KB');
     });
+
+    it('Should return 890 KB #2', () => {
+       
+        const result = pipe.transform(890, 0, 'KB');
+        expect(result).toEqual('890 KB');
+    });
 
 
     it('Should return 1023 KB', () => {
@@ -58,6 +70,13 @@ describe('BytesPipe', () => {
         const result = pipe.transform(mb, 0);
         expect(result).toEqual('241 MB');
     });
+
+     it('Should return 241 MB', () => {
+       
+        const mb = 240.5691 / 1024;
+        const result = pipe.transform(mb, 0, 'GB');
+        expect(result).toEqual('241 MB');
+    });
 
     it('Should return 240.54 MB', () => {
 
@@ -72,14 +91,29 @@ describe('BytesPipe', () => {
         const result = pipe.transform(mb, 2);
         expect(result).toEqual('1023 MB');
     });
+
+     it('Should return 1023 MB #2', () => {
+       
+        const kb = 1024 * 1023;
+        const result = pipe.transform(kb, 2, 'KB');
+        expect(result).toEqual('1023 MB');
+    });
 
-    it('Should return 1059 GB', () => {
+    it('Should return 1023 GB', () => {
+       
+        const gb = 1024 * 1024 * 1024 * 1023;
+        const result = pipe.transform(gb, 2);
+        expect(result).toEqual('1023 GB');
+    });
+
+      it('Should return 1.03 TB', () => {
 
         const gb = 1024 * 1024 * 1024 * 1059;
         const result = pipe.transform(gb, 2);
-        expect(result).toEqual('1059 GB');
+        expect(result).toEqual('1.03 TB');
     });
 
+
     it('Should return the input', () => {
         expect(pipe.transform('a')).toEqual('a');
     });

src/math/bytes.pipe.ts

@@ -1,42 +1,53 @@
 import { Pipe, PipeTransform  } from '@angular/core';
 import { isNumberFinite, isPositive, isInteger, toDecimal } from '../utils/utils';
 
+export type ByteUnit = 'B' | 'KB' | 'MB' | 'GB' | 'TB';
+
+
+
 
 @Pipe({
   name: 'bytes'
 })
 export class BytesPipe implements PipeTransform {
+
+  static formats: { [key: string]: { max: number, prev?: ByteUnit }} = {
+    'B': { max: 1024 },
+    'KB': { max: Math.pow(1024, 2), prev: 'B' },
+    'MB': { max: Math.pow(1024, 3), prev: 'KB' },
+    'GB': { max: Math.pow(1024, 4), prev: 'MB' },
+    'TB': { max: Number.MAX_SAFE_INTEGER, prev: 'GB' }
+  };
+
 
-  transform (input: any, decimal: number = 0): any {
-    
-    const formats = [
-      { name: 'B', max: 1024 },
-      { name: 'KB', max: 1048576 },
-      { name: 'MB', max: 1073741824 },
-      { name: 'GB', max: Number.MAX_VALUE }
-    ];
+  transform (input: any, decimal: number = 0, from: ByteUnit = 'B'): any {
 
-    if (isNumberFinite(input) && 
+    if (!(isNumberFinite(input) && 
         isNumberFinite(decimal) && 
         isInteger(decimal) && 
-        isPositive(decimal)) {
-      
-      for (let i = 0; i < formats.length; ++i) {
-        const format = formats[i];
-        if (input < format.max) {
-          
-          const bytes = formats[i - 1] ?
-          toDecimal(input / formats[i - 1].max, decimal) : 
-          toDecimal(input, decimal);
-          
-          return `${bytes} ${format.name}`;
-        } 
-        
-      }
-      
+        isPositive(decimal))) {
+          return input;
     }
-    else {
-      return input;
+
+    let bytes = input;
+    let unit = from;
+    while (unit != 'B') {
+      bytes *= 1024;
+      unit = BytesPipe.formats[unit].prev;
+    }
+
+    for (const key in BytesPipe.formats) {
+      const format = BytesPipe.formats[key];
+      if (bytes < format.max) {
+
+        const prev = BytesPipe.formats[format.prev];
+        
+        const result = prev ?
+          toDecimal(bytes / prev.max, decimal) : 
+          toDecimal(bytes, decimal);
+        
+        return `${result} ${key}`;
+      } 
     }
   }
 }