@bgord/tools 1.0.2 → 1.0.4

package/dist/duration.service.d.ts

@@ -6,12 +6,15 @@ export declare class Duration {
     private static readonly MS_IN_MINUTE;
     private static readonly MS_IN_HOUR;
     private static readonly MS_IN_DAY;
+    private static readonly MS_IN_WEEK;
     private constructor();
+    static Weeks(value: number): Duration;
     static Days(value: number): Duration;
     static Hours(value: number): Duration;
     static Minutes(value: number): Duration;
     static Seconds(value: number): Duration;
     static Ms(value: number): Duration;
+    get weeks(): number;
     get days(): number;
     get hours(): number;
     get minutes(): number;

package/dist/duration.service.js

@@ -7,9 +7,13 @@ export class Duration {
     static MS_IN_MINUTE = 60 * Duration.MS_IN_SECOND;
     static MS_IN_HOUR = 60 * Duration.MS_IN_MINUTE;
     static MS_IN_DAY = 24 * Duration.MS_IN_HOUR;
+    static MS_IN_WEEK = 7 * Duration.MS_IN_DAY;
     constructor(candidateMs) {
         this.internal = DurationMs.parse(candidateMs);
     }
+    static Weeks(value) {
+        return new Duration(value * Duration.MS_IN_WEEK);
+    }
     static Days(value) {
         return new Duration(value * Duration.MS_IN_DAY);
     }
@@ -25,6 +29,9 @@ export class Duration {
     static Ms(value) {
         return new Duration(value);
     }
+    get weeks() {
+        return Duration.rounding.round(this.internal / Duration.MS_IN_WEEK);
+    }
     get days() {
         return Duration.rounding.round(this.internal / Duration.MS_IN_DAY);
     }

package/dist/size.vo.d.ts

@@ -15,13 +15,17 @@ export declare class Size {
     private static readonly KB_MULTIPLIER;
     private static readonly MB_MULTIPLIER;
     private static readonly GB_MULTIPLIER;
-    private static readonly ROUNDER;
+    private static readonly CONVERT_ROUND;
+    private static readonly FORMAT_ROUND;
     constructor(config: SizeConfigType);
     static fromBytes(value: SizeConfigType["value"]): Size;
     static fromKb(value: SizeConfigType["value"]): Size;
     static fromMB(value: SizeConfigType["value"]): Size;
     static fromGB(value: SizeConfigType["value"]): Size;
     toBytes(): SizeBytesType;
+    tokB(): number;
+    toMB(): number;
+    toGB(): number;
     isGreaterThan(another: Size): boolean;
     format(unit: SizeUnitEnum): string;
     static toBytes(config: SizeConfigType): SizeBytesType;

package/dist/size.vo.js

@@ -1,4 +1,4 @@
-import { RoundToDecimal } from "./rounding.adapter";
+import { RoundToDecimal, RoundUp } from "./rounding.adapter";
 import { SizeBytes } from "./size-bytes.vo";
 var SizeUnitEnum;
 (function (SizeUnitEnum) {
@@ -13,7 +13,8 @@ export class Size {
     static KB_MULTIPLIER = 1024;
     static MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
     static GB_MULTIPLIER = 1024 * Size.MB_MULTIPLIER;
-    static ROUNDER = new RoundToDecimal(2);
+    static CONVERT_ROUND = new RoundUp();
+    static FORMAT_ROUND = new RoundToDecimal(2);
     constructor(config) {
         this.unit = config.unit;
         this.bytes = this.calculateBytes(config.value, config.unit);
@@ -33,17 +34,26 @@ export class Size {
     toBytes() {
         return this.bytes;
     }
+    tokB() {
+        return Size.CONVERT_ROUND.round(this.bytes / Size.KB_MULTIPLIER);
+    }
+    toMB() {
+        return Size.CONVERT_ROUND.round(this.bytes / Size.MB_MULTIPLIER);
+    }
+    toGB() {
+        return Size.CONVERT_ROUND.round(this.bytes / Size.GB_MULTIPLIER);
+    }
     isGreaterThan(another) {
         return this.bytes > another.toBytes();
     }
     format(unit) {
         switch (unit) {
             case SizeUnitEnum.kB:
-                return `${Size.ROUNDER.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
+                return `${Size.FORMAT_ROUND.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
             case SizeUnitEnum.MB:
-                return `${Size.ROUNDER.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
+                return `${Size.FORMAT_ROUND.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
             case SizeUnitEnum.GB:
-                return `${Size.ROUNDER.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
+                return `${Size.FORMAT_ROUND.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
             default:
                 return `${this.bytes} ${SizeUnitEnum.b}`;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/tools",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "license": "MIT",
   "author": "Bartosz Gordon",
@@ -21,7 +21,7 @@
     "preinstall": "bunx only-allow bun"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.0",
+    "@biomejs/biome": "2.3.1",
     "@commitlint/cli": "20.1.0",
     "@commitlint/config-conventional": "20.0.0",
     "@types/bun": "1.3.1",

package/src/duration.service.ts

@@ -10,11 +10,16 @@ export class Duration {
   private static readonly MS_IN_MINUTE = 60 * Duration.MS_IN_SECOND;
   private static readonly MS_IN_HOUR = 60 * Duration.MS_IN_MINUTE;
   private static readonly MS_IN_DAY = 24 * Duration.MS_IN_HOUR;
+  private static readonly MS_IN_WEEK = 7 * Duration.MS_IN_DAY;
 
   private constructor(candidateMs: number) {
     this.internal = DurationMs.parse(candidateMs);
   }
 
+  static Weeks(value: number): Duration {
+    return new Duration(value * Duration.MS_IN_WEEK);
+  }
+
   static Days(value: number): Duration {
     return new Duration(value * Duration.MS_IN_DAY);
   }
@@ -31,6 +36,10 @@ export class Duration {
     return new Duration(value);
   }
 
+  get weeks(): number {
+    return Duration.rounding.round(this.internal / Duration.MS_IN_WEEK);
+  }
+
   get days(): number {
     return Duration.rounding.round(this.internal / Duration.MS_IN_DAY);
   }

package/src/size.vo.ts

@@ -1,4 +1,4 @@
-import { RoundToDecimal } from "./rounding.adapter";
+import { RoundToDecimal, RoundUp } from "./rounding.adapter";
 import { SizeBytes, type SizeBytesType } from "./size-bytes.vo";
 
 enum SizeUnitEnum {
@@ -18,7 +18,8 @@ export class Size {
   private static readonly MB_MULTIPLIER = 1024 * Size.KB_MULTIPLIER;
   private static readonly GB_MULTIPLIER = 1024 * Size.MB_MULTIPLIER;
 
-  private static readonly ROUNDER = new RoundToDecimal(2);
+  private static readonly CONVERT_ROUND = new RoundUp();
+  private static readonly FORMAT_ROUND = new RoundToDecimal(2);
 
   constructor(config: SizeConfigType) {
     this.unit = config.unit;
@@ -45,6 +46,18 @@ export class Size {
     return this.bytes;
   }
 
+  tokB(): number {
+    return Size.CONVERT_ROUND.round(this.bytes / Size.KB_MULTIPLIER);
+  }
+
+  toMB(): number {
+    return Size.CONVERT_ROUND.round(this.bytes / Size.MB_MULTIPLIER);
+  }
+
+  toGB(): number {
+    return Size.CONVERT_ROUND.round(this.bytes / Size.GB_MULTIPLIER);
+  }
+
   isGreaterThan(another: Size): boolean {
     return this.bytes > another.toBytes();
   }
@@ -52,11 +65,11 @@ export class Size {
   format(unit: SizeUnitEnum): string {
     switch (unit) {
       case SizeUnitEnum.kB:
-        return `${Size.ROUNDER.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
+        return `${Size.FORMAT_ROUND.round(this.bytes / Size.KB_MULTIPLIER)} ${SizeUnitEnum.kB}`;
       case SizeUnitEnum.MB:
-        return `${Size.ROUNDER.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
+        return `${Size.FORMAT_ROUND.round(this.bytes / Size.MB_MULTIPLIER)} ${SizeUnitEnum.MB}`;
       case SizeUnitEnum.GB:
-        return `${Size.ROUNDER.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
+        return `${Size.FORMAT_ROUND.round(this.bytes / Size.GB_MULTIPLIER)} ${SizeUnitEnum.GB}`;
       default:
         return `${this.bytes} ${SizeUnitEnum.b}`;
     }