@futdevpro/fsm-dynamo 1.15.18 → 1.15.20

package/src/_collections/utils/data.util.ts

@@ -1,226 +1,226 @@
-import { kilobyte, megabyte, gigabyte, terabyte, petabyte, exabyte, zettabyte, yottabyte } from '../constants/data-sizes.const';
-import { DyFM_Math } from './math/math.util';
-
-/**
- * Data utility class
- *
- * Hungarian documentation (Hunglish):
- * - Ez a utility data-size konverziókra fókuszál, ember-barát string formátummal
- * - A számítás 1024-es alapot használ (KB/MB/GB/TB)
- * - A `getSizeString` adja vissza a rövidített formátumot, pl.: `1.5KB`, `12MB`, `1GB 256MB`
- */
-export class DyFM_Data {
-
-  /**
-   * A kilobyte (1024 B) egység
-   */
-  static readonly kilobyte: number = kilobyte;
-
-  /**
-   * A megabyte (1024 KB) egység
-   */
-  static readonly megabyte: number = megabyte;
-
-  /**
-   * A gigabyte (1024 MB) egység
-   */
-  static readonly gigabyte: number = gigabyte;
-
-  /**
-   * A terabyte (1024 GB) egység
-   */
-  static readonly terabyte: number = terabyte;
-
-  /**
-   * A petabyte (1024 TB) egység
-   */
-  static readonly petabyte: number = petabyte;
-
-  /**
-   * A exabyte (1024 PB) egység
-   */
-  static readonly exabyte: number = exabyte;
-
-  /**
-   * A zettabyte (1024 EB) egység
-   */
-  static readonly zettabyte: number = zettabyte;
-
-  /**
-   * A yottabyte (1024 ZB) egység
-   */
-  static readonly yottabyte: number = yottabyte;
-
-  /**
-   * Size-et ad vissza ember-barát string-ként.
-   * - 1024-es váltószámot használunk (KB/MB/GB/TB)
-   * - Negatív értékeknél `-` jel kerül az elejére (abszolút értékkel számolunk)
-   * - `full=true` esetén a következő kisebb egység maradéka is megjelenik (pl. `1GB 256MB`)
-   *
-   * Példák:
-   * ```ts
-   * DyFM_Data.getSizeString(0);               // '0B'
-   * DyFM_Data.getSizeString(1536);            // '1.5KB'
-   * DyFM_Data.getSizeString(1536, 0, true);   // '2KB 0B'
-   * DyFM_Data.getSizeString(1_234_567);       // '1.18MB'
-   * DyFM_Data.getSizeString(1_234_567, 0);    // '1MB'
-   * DyFM_Data.getSizeString(1_500_000_000);   // '1.4GB'
-   * ```
-   */
-  static getSizeString(size: number, decimals?: number, full?: boolean): string {
-    // Edge case: 0 → rögtön visszaadjuk
-    if (size === 0) {
-      return '0B';
-    }
-
-    if (!size) {
-      return 'N/A';
-    }
-
-    // Negatív jel kezelése, számítás abszolút értékkel
-    const isNegative: boolean = size < 0;
-    let remaining: number = Math.abs(size);
-
-    // < 1KB → B (decimals nélkül)
-    if (remaining < this.kilobyte) {
-      const sign: string = isNegative ? '-' : '';
-      return `${sign}${Math.floor(remaining)}B`;
-    }
-
-    // KB
-    if (remaining < this.megabyte) {
-      const kb: number = remaining / this.kilobyte;
-      if (full) {
-        const kbWhole: number = Math.floor(kb);
-        const remainderAfterKb: number = remaining - (kbWhole * this.kilobyte);
-        const bRemainder: number = Math.floor(remainderAfterKb);
-        const sign: string = isNegative ? '-' : '';
-        if (bRemainder > 0) {
-          return `${sign}${kbWhole}KB ${bRemainder}B`;
-        }
-        return `${sign}${kbWhole}KB`;
-      }
-      const str: string = `${DyFM_Math.round(kb, decimals ?? (Number.isInteger(kb) ? 0 : 2))}KB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // MB
-    if (remaining < this.gigabyte) {
-      const mb: number = remaining / this.megabyte;
-      if (full) {
-        const mbWhole: number = Math.floor(mb);
-        const remainderAfterMb: number = remaining - (mbWhole * this.megabyte);
-        const kbRemainder: number = Math.floor(remainderAfterMb / this.kilobyte);
-        const sign: string = isNegative ? '-' : '';
-        if (kbRemainder > 0) {
-          return `${sign}${mbWhole}MB ${kbRemainder}KB`;
-        }
-        return `${sign}${mbWhole}MB`;
-      }
-      const str: string = `${DyFM_Math.round(mb, decimals ?? (Number.isInteger(mb) ? 0 : 2))}MB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // GB
-    if (remaining < this.terabyte) {
-      const gb: number = remaining / this.gigabyte;
-      if (full) {
-        const gbWhole: number = Math.floor(gb);
-        const remainderAfterGb: number = remaining - (gbWhole * this.gigabyte);
-        const mbRemainder: number = Math.floor(remainderAfterGb / this.megabyte);
-        const sign: string = isNegative ? '-' : '';
-        if (mbRemainder > 0) {
-          return `${sign}${gbWhole}GB ${mbRemainder}MB`;
-        }
-        return `${sign}${gbWhole}GB`;
-      }
-      const str: string = `${DyFM_Math.round(gb, decimals ?? (Number.isInteger(gb) ? 0 : 2))}GB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // TB
-    if (remaining < this.petabyte) {
-      const tb: number = remaining / this.terabyte;
-      if (full) {
-        const tbWhole: number = Math.floor(tb);
-        const remainderAfterTb: number = remaining - (tbWhole * this.terabyte);
-        const gbRemainder: number = Math.floor(remainderAfterTb / this.gigabyte);
-        const sign: string = isNegative ? '-' : '';
-        if (gbRemainder > 0) {
-          return `${sign}${tbWhole}TB ${gbRemainder}GB`;
-        }
-        return `${sign}${tbWhole}TB`;
-      }
-      const str: string = `${DyFM_Math.round(tb, decimals ?? (Number.isInteger(tb) ? 0 : 2))}TB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // PB
-    if (remaining < this.exabyte) {
-      const pb: number = remaining / this.petabyte;
-      if (full) {
-        const pbWhole: number = Math.floor(pb);
-        const remainderAfterPb: number = remaining - (pbWhole * this.petabyte);
-        const tbRemainder: number = Math.floor(remainderAfterPb / this.terabyte);
-        const sign: string = isNegative ? '-' : '';
-        if (tbRemainder > 0) {
-          return `${sign}${pbWhole}PB ${tbRemainder}TB`;
-        }
-        return `${sign}${pbWhole}PB`;
-      }
-      const str: string = `${DyFM_Math.round(pb, decimals ?? (Number.isInteger(pb) ? 0 : 2))}PB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // EB
-    if (remaining < this.zettabyte) {
-      const eb: number = remaining / this.exabyte;
-      if (full) {
-        const ebWhole: number = Math.floor(eb);
-        const remainderAfterEb: number = remaining - (ebWhole * this.exabyte);
-        const pbRemainder: number = Math.floor(remainderAfterEb / this.petabyte);
-        const sign: string = isNegative ? '-' : '';
-        if (pbRemainder > 0) {
-          return `${sign}${ebWhole}EB ${pbRemainder}PB`;
-        }
-        return `${sign}${ebWhole}EB`;
-      }
-      const str: string = `${DyFM_Math.round(eb, decimals ?? (Number.isInteger(eb) ? 0 : 2))}EB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // ZB
-    if (remaining < this.yottabyte) {
-      const zb: number = remaining / this.zettabyte;
-      if (full) {
-        const zbWhole: number = Math.floor(zb);
-        const remainderAfterZb: number = remaining - (zbWhole * this.zettabyte);
-        const ebRemainder: number = Math.floor(remainderAfterZb / this.exabyte);
-        const sign: string = isNegative ? '-' : '';
-        if (ebRemainder > 0) {
-          return `${sign}${zbWhole}ZB ${ebRemainder}EB`;
-        }
-        return `${sign}${zbWhole}ZB`;
-      }
-      const str: string = `${DyFM_Math.round(zb, decimals ?? (Number.isInteger(zb) ? 0 : 2))}ZB`;
-      return isNegative ? `-${str}` : str;
-    }
-
-    // YB
-    const yb: number = remaining / this.yottabyte;
-    if (full) {
-      const ybWhole: number = Math.floor(yb);
-      const remainderAfterYb: number = remaining - (ybWhole * this.yottabyte);
-      const zbRemainder: number = Math.floor(remainderAfterYb / this.zettabyte);
-      const sign: string = isNegative ? '-' : '';
-      if (zbRemainder > 0) {
-        return `${sign}${ybWhole}YB ${zbRemainder}ZB`;
-      }
-      return `${sign}${ybWhole}YB`;
-    }
-    const str: string = `${DyFM_Math.round(yb, decimals ?? (Number.isInteger(yb) ? 0 : 2))}YB`;
-    return isNegative ? `-${str}` : str;
-  }
-}
-
-
+import { kilobyte, megabyte, gigabyte, terabyte, petabyte, exabyte, zettabyte, yottabyte } from '../constants/data-sizes.const';
+import { DyFM_Math } from './math/math.util';
+
+/**
+ * Data utility class
+ *
+ * Hungarian documentation (Hunglish):
+ * - Ez a utility data-size konverziókra fókuszál, ember-barát string formátummal
+ * - A számítás 1024-es alapot használ (KB/MB/GB/TB)
+ * - A `getSizeString` adja vissza a rövidített formátumot, pl.: `1.5KB`, `12MB`, `1GB 256MB`
+ */
+export class DyFM_Data {
+
+  /**
+   * A kilobyte (1024 B) egység
+   */
+  static readonly kilobyte: number = kilobyte;
+
+  /**
+   * A megabyte (1024 KB) egység
+   */
+  static readonly megabyte: number = megabyte;
+
+  /**
+   * A gigabyte (1024 MB) egység
+   */
+  static readonly gigabyte: number = gigabyte;
+
+  /**
+   * A terabyte (1024 GB) egység
+   */
+  static readonly terabyte: number = terabyte;
+
+  /**
+   * A petabyte (1024 TB) egység
+   */
+  static readonly petabyte: number = petabyte;
+
+  /**
+   * A exabyte (1024 PB) egység
+   */
+  static readonly exabyte: number = exabyte;
+
+  /**
+   * A zettabyte (1024 EB) egység
+   */
+  static readonly zettabyte: number = zettabyte;
+
+  /**
+   * A yottabyte (1024 ZB) egység
+   */
+  static readonly yottabyte: number = yottabyte;
+
+  /**
+   * Size-et ad vissza ember-barát string-ként.
+   * - 1024-es váltószámot használunk (KB/MB/GB/TB)
+   * - Negatív értékeknél `-` jel kerül az elejére (abszolút értékkel számolunk)
+   * - `full=true` esetén a következő kisebb egység maradéka is megjelenik (pl. `1GB 256MB`)
+   *
+   * Példák:
+   * ```ts
+   * DyFM_Data.getSizeString(0);               // '0B'
+   * DyFM_Data.getSizeString(1536);            // '1.5KB'
+   * DyFM_Data.getSizeString(1536, 0, true);   // '2KB 0B'
+   * DyFM_Data.getSizeString(1_234_567);       // '1.18MB'
+   * DyFM_Data.getSizeString(1_234_567, 0);    // '1MB'
+   * DyFM_Data.getSizeString(1_500_000_000);   // '1.4GB'
+   * ```
+   */
+  static getSizeString(size: number, decimals?: number, full?: boolean): string {
+    // Edge case: 0 → rögtön visszaadjuk
+    if (size === 0) {
+      return '0B';
+    }
+
+    if (!size) {
+      return 'N/A';
+    }
+
+    // Negatív jel kezelése, számítás abszolút értékkel
+    const isNegative: boolean = size < 0;
+    let remaining: number = Math.abs(size);
+
+    // < 1KB → B (decimals nélkül)
+    if (remaining < this.kilobyte) {
+      const sign: string = isNegative ? '-' : '';
+      return `${sign}${Math.floor(remaining)}B`;
+    }
+
+    // KB
+    if (remaining < this.megabyte) {
+      const kb: number = remaining / this.kilobyte;
+      if (full) {
+        const kbWhole: number = Math.floor(kb);
+        const remainderAfterKb: number = remaining - (kbWhole * this.kilobyte);
+        const bRemainder: number = Math.floor(remainderAfterKb);
+        const sign: string = isNegative ? '-' : '';
+        if (bRemainder > 0) {
+          return `${sign}${kbWhole}KB ${bRemainder}B`;
+        }
+        return `${sign}${kbWhole}KB`;
+      }
+      const str: string = `${DyFM_Math.round(kb, decimals ?? (Number.isInteger(kb) ? 0 : 2))}KB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // MB
+    if (remaining < this.gigabyte) {
+      const mb: number = remaining / this.megabyte;
+      if (full) {
+        const mbWhole: number = Math.floor(mb);
+        const remainderAfterMb: number = remaining - (mbWhole * this.megabyte);
+        const kbRemainder: number = Math.floor(remainderAfterMb / this.kilobyte);
+        const sign: string = isNegative ? '-' : '';
+        if (kbRemainder > 0) {
+          return `${sign}${mbWhole}MB ${kbRemainder}KB`;
+        }
+        return `${sign}${mbWhole}MB`;
+      }
+      const str: string = `${DyFM_Math.round(mb, decimals ?? (Number.isInteger(mb) ? 0 : 2))}MB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // GB
+    if (remaining < this.terabyte) {
+      const gb: number = remaining / this.gigabyte;
+      if (full) {
+        const gbWhole: number = Math.floor(gb);
+        const remainderAfterGb: number = remaining - (gbWhole * this.gigabyte);
+        const mbRemainder: number = Math.floor(remainderAfterGb / this.megabyte);
+        const sign: string = isNegative ? '-' : '';
+        if (mbRemainder > 0) {
+          return `${sign}${gbWhole}GB ${mbRemainder}MB`;
+        }
+        return `${sign}${gbWhole}GB`;
+      }
+      const str: string = `${DyFM_Math.round(gb, decimals ?? (Number.isInteger(gb) ? 0 : 2))}GB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // TB
+    if (remaining < this.petabyte) {
+      const tb: number = remaining / this.terabyte;
+      if (full) {
+        const tbWhole: number = Math.floor(tb);
+        const remainderAfterTb: number = remaining - (tbWhole * this.terabyte);
+        const gbRemainder: number = Math.floor(remainderAfterTb / this.gigabyte);
+        const sign: string = isNegative ? '-' : '';
+        if (gbRemainder > 0) {
+          return `${sign}${tbWhole}TB ${gbRemainder}GB`;
+        }
+        return `${sign}${tbWhole}TB`;
+      }
+      const str: string = `${DyFM_Math.round(tb, decimals ?? (Number.isInteger(tb) ? 0 : 2))}TB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // PB
+    if (remaining < this.exabyte) {
+      const pb: number = remaining / this.petabyte;
+      if (full) {
+        const pbWhole: number = Math.floor(pb);
+        const remainderAfterPb: number = remaining - (pbWhole * this.petabyte);
+        const tbRemainder: number = Math.floor(remainderAfterPb / this.terabyte);
+        const sign: string = isNegative ? '-' : '';
+        if (tbRemainder > 0) {
+          return `${sign}${pbWhole}PB ${tbRemainder}TB`;
+        }
+        return `${sign}${pbWhole}PB`;
+      }
+      const str: string = `${DyFM_Math.round(pb, decimals ?? (Number.isInteger(pb) ? 0 : 2))}PB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // EB
+    if (remaining < this.zettabyte) {
+      const eb: number = remaining / this.exabyte;
+      if (full) {
+        const ebWhole: number = Math.floor(eb);
+        const remainderAfterEb: number = remaining - (ebWhole * this.exabyte);
+        const pbRemainder: number = Math.floor(remainderAfterEb / this.petabyte);
+        const sign: string = isNegative ? '-' : '';
+        if (pbRemainder > 0) {
+          return `${sign}${ebWhole}EB ${pbRemainder}PB`;
+        }
+        return `${sign}${ebWhole}EB`;
+      }
+      const str: string = `${DyFM_Math.round(eb, decimals ?? (Number.isInteger(eb) ? 0 : 2))}EB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // ZB
+    if (remaining < this.yottabyte) {
+      const zb: number = remaining / this.zettabyte;
+      if (full) {
+        const zbWhole: number = Math.floor(zb);
+        const remainderAfterZb: number = remaining - (zbWhole * this.zettabyte);
+        const ebRemainder: number = Math.floor(remainderAfterZb / this.exabyte);
+        const sign: string = isNegative ? '-' : '';
+        if (ebRemainder > 0) {
+          return `${sign}${zbWhole}ZB ${ebRemainder}EB`;
+        }
+        return `${sign}${zbWhole}ZB`;
+      }
+      const str: string = `${DyFM_Math.round(zb, decimals ?? (Number.isInteger(zb) ? 0 : 2))}ZB`;
+      return isNegative ? `-${str}` : str;
+    }
+
+    // YB
+    const yb: number = remaining / this.yottabyte;
+    if (full) {
+      const ybWhole: number = Math.floor(yb);
+      const remainderAfterYb: number = remaining - (ybWhole * this.yottabyte);
+      const zbRemainder: number = Math.floor(remainderAfterYb / this.zettabyte);
+      const sign: string = isNegative ? '-' : '';
+      if (zbRemainder > 0) {
+        return `${sign}${ybWhole}YB ${zbRemainder}ZB`;
+      }
+      return `${sign}${ybWhole}YB`;
+    }
+    const str: string = `${DyFM_Math.round(yb, decimals ?? (Number.isInteger(yb) ? 0 : 2))}YB`;
+    return isNegative ? `-${str}` : str;
+  }
+}
+
+