@futdevpro/fsm-dynamo 1.20.9 → 1.20.12

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

@@ -1,345 +0,0 @@
-import { DyFM_Data } from './data.util';
-import { DyFM_Math } from './math/math.util';
-
-describe('| DyFM_Data', (): void => {
-
-  describe('| constants', (): void => {
-    it('| should have correct kilobyte value', (): void => {
-      expect(DyFM_Data.kilobyte).toBe(1024);
-    });
-
-    it('| should have correct megabyte value', (): void => {
-      expect(DyFM_Data.megabyte).toBe(1024 * 1024);
-    });
-
-    it('| should have correct gigabyte value', (): void => {
-      expect(DyFM_Data.gigabyte).toBe(1024 * 1024 * 1024);
-    });
-
-    it('| should have correct terabyte value', (): void => {
-      expect(DyFM_Data.terabyte).toBe(1024 * 1024 * 1024 * 1024);
-    });
-  });
-
-  describe('| getSizeString', (): void => {
-    it('| should return "0B" for zero size', (): void => {
-      expect(DyFM_Data.getSizeString(0)).toBe('0B');
-    });
-
-    it('| should return "N/A" for null or undefined size', (): void => {
-      expect(DyFM_Data.getSizeString(null as any)).toBe('N/A');
-      expect(DyFM_Data.getSizeString(undefined as any)).toBe('N/A');
-    });
-
-    it('| should format bytes less than 1KB', (): void => {
-      expect(DyFM_Data.getSizeString(512)).toBe('512B');
-      expect(DyFM_Data.getSizeString(1023)).toBe('1023B');
-    });
-
-    it('| should format kilobytes', (): void => {
-      expect(DyFM_Data.getSizeString(1536)).toBe('1.5KB');
-      expect(DyFM_Data.getSizeString(2048)).toBe('2KB');
-      expect(DyFM_Data.getSizeString(1024 * 10)).toBe('10KB');
-    });
-
-    it('| should format megabytes', (): void => {
-      expect(DyFM_Data.getSizeString(1024 * 1024)).toBe('1MB');
-      expect(DyFM_Data.getSizeString(1024 * 1024 * 1.5)).toBe('1.5MB');
-      expect(DyFM_Data.getSizeString(1024 * 1024 * 10)).toBe('10MB');
-    });
-
-    it('| should format gigabytes', (): void => {
-      expect(DyFM_Data.getSizeString(1024 * 1024 * 1024)).toBe('1GB');
-      expect(DyFM_Data.getSizeString(1024 * 1024 * 1024 * 1.5)).toBe('1.5GB');
-    });
-
-    it('| should format terabytes', (): void => {
-      expect(DyFM_Data.getSizeString(1024 * 1024 * 1024 * 1024)).toBe('1TB');
-    });
-
-    it('| should handle negative values', (): void => {
-      expect(DyFM_Data.getSizeString(-512)).toBe('-512B');
-      expect(DyFM_Data.getSizeString(-1536)).toBe('-1.5KB');
-    });
-
-    it('| should use custom decimals when provided', (): void => {
-      expect(DyFM_Data.getSizeString(1536, 1)).toBe('1.5KB');
-      expect(DyFM_Data.getSizeString(1536, 3)).toBe('1.5KB');
-      expect(DyFM_Data.getSizeString(1536, 0)).toBe('2KB');
-    });
-
-    it('| should show full format with remainder when full=true', (): void => {
-      const result = DyFM_Data.getSizeString(1536, 0, true);
-      expect(result).toContain('KB');
-      expect(result).toContain('B');
-    });
-
-    it('| should show full format for megabytes with remainder', (): void => {
-      const size = DyFM_Data.megabyte + DyFM_Data.kilobyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('MB');
-      expect(result).toContain('KB');
-    });
-
-    it('| should show full format for gigabytes with remainder', (): void => {
-      const size = DyFM_Data.gigabyte + DyFM_Data.megabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('GB');
-      expect(result).toContain('MB');
-    });
-
-    it('| should handle very large sizes', (): void => {
-      const petabyte = DyFM_Data.petabyte;
-      expect(DyFM_Data.getSizeString(petabyte)).toContain('PB');
-    });
-
-    it('| should format petabytes', (): void => {
-      expect(DyFM_Data.getSizeString(DyFM_Data.petabyte)).toBe('1PB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.petabyte * 1.5)).toBe('1.5PB');
-    });
-
-    it('| should format exabytes', (): void => {
-      expect(DyFM_Data.getSizeString(DyFM_Data.exabyte)).toBe('1EB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.exabyte * 2.5)).toBe('2.5EB');
-    });
-
-    it('| should format zettabytes', (): void => {
-      expect(DyFM_Data.getSizeString(DyFM_Data.zettabyte)).toBe('1ZB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.zettabyte * 3.7)).toBe('3.7ZB');
-    });
-
-    it('| should format yottabytes', (): void => {
-      expect(DyFM_Data.getSizeString(DyFM_Data.yottabyte)).toBe('1YB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.yottabyte * 4.2)).toBe('4.2YB');
-    });
-
-    it('| should handle edge case at exact unit boundaries', (): void => {
-      expect(DyFM_Data.getSizeString(DyFM_Data.kilobyte)).toBe('1KB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.megabyte)).toBe('1MB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.gigabyte)).toBe('1GB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.terabyte)).toBe('1TB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.petabyte)).toBe('1PB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.exabyte)).toBe('1EB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.zettabyte)).toBe('1ZB');
-      expect(DyFM_Data.getSizeString(DyFM_Data.yottabyte)).toBe('1YB');
-    });
-
-    it('| should not show remainder in full format when remainder is zero', (): void => {
-      const result = DyFM_Data.getSizeString(DyFM_Data.kilobyte, 0, true);
-      expect(result).toBe('1KB');
-      expect(result).not.toContain('0B');
-    });
-
-    it('| should show full format for terabytes with remainder', (): void => {
-      const size = DyFM_Data.terabyte + DyFM_Data.gigabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('TB');
-      expect(result).toContain('GB');
-    });
-
-    it('| should show full format for petabytes with remainder', (): void => {
-      const size = DyFM_Data.petabyte + DyFM_Data.terabyte * 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('PB');
-      expect(result).toContain('TB');
-    });
-
-    it('| should handle negative values with full format', (): void => {
-      const result = DyFM_Data.getSizeString(-1536, 0, true);
-      expect(result).toContain('-');
-      expect(result).toContain('KB');
-    });
-
-    it('| should handle very large negative values', (): void => {
-      const result = DyFM_Data.getSizeString(-DyFM_Data.gigabyte);
-      expect(result).toContain('-');
-      expect(result).toContain('GB');
-    });
-
-    it('| should handle custom decimals for large sizes', (): void => {
-      const size = DyFM_Data.terabyte * 1.234;
-      const result = DyFM_Data.getSizeString(size, 3);
-      expect(result).toContain('TB');
-      expect(result).toMatch(/1\.\d{3}TB/);
-    });
-
-    it('| should show full format for exabytes with remainder', (): void => {
-      const size = DyFM_Data.exabyte + DyFM_Data.petabyte * 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('EB');
-      expect(result).toContain('PB');
-    });
-
-    it('| should show full format for zettabytes with remainder', (): void => {
-      const size = DyFM_Data.zettabyte + DyFM_Data.exabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('ZB');
-      expect(result).toContain('EB');
-    });
-
-    it('| should show full format for yottabytes with remainder', (): void => {
-      const size = DyFM_Data.yottabyte + DyFM_Data.zettabyte * 128;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('YB');
-      expect(result).toContain('ZB');
-    });
-
-    it('| should not show remainder in full format for exabytes when remainder is zero', (): void => {
-      const result = DyFM_Data.getSizeString(DyFM_Data.exabyte, 0, true);
-      expect(result).toBe('1EB');
-      expect(result).not.toContain('0PB');
-    });
-
-    it('| should not show remainder in full format for zettabytes when remainder is zero', (): void => {
-      const result = DyFM_Data.getSizeString(DyFM_Data.zettabyte, 0, true);
-      expect(result).toBe('1ZB');
-      expect(result).not.toContain('0EB');
-    });
-
-    it('| should not show remainder in full format for yottabytes when remainder is zero', (): void => {
-      const result = DyFM_Data.getSizeString(DyFM_Data.yottabyte, 0, true);
-      expect(result).toBe('1YB');
-      expect(result).not.toContain('0ZB');
-    });
-
-    it('| should handle KB with remainder in full format', (): void => {
-      const size = DyFM_Data.kilobyte + 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('KB');
-      expect(result).toContain('B');
-    });
-
-    it('| should handle negative KB with remainder in full format', (): void => {
-      const size = -(DyFM_Data.kilobyte + 512);
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('-');
-      expect(result).toContain('KB');
-    });
-
-    it('| should handle PB without remainder in full format', (): void => {
-      // Test case for line 169-170: PB without remainder case
-      const size = DyFM_Data.petabyte; // Exactly 1 PB
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toBe('1PB');
-      expect(result).not.toContain('TB');
-    });
-
-    it('| should handle PB with remainder in full format', (): void => {
-      // Test case for line 166-167: PB with remainder
-      const size = DyFM_Data.petabyte + DyFM_Data.terabyte * 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('PB');
-      expect(result).toContain('TB');
-    });
-
-    it('| should handle all size ranges with full format - KB', (): void => {
-      const size = DyFM_Data.kilobyte + 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('KB');
-      expect(result).toContain('B');
-    });
-
-    it('| should handle all size ranges with full format - MB', (): void => {
-      const size = DyFM_Data.megabyte + DyFM_Data.kilobyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('MB');
-      expect(result).toContain('KB');
-    });
-
-    it('| should handle all size ranges with full format - GB', (): void => {
-      const size = DyFM_Data.gigabyte + DyFM_Data.megabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('GB');
-      expect(result).toContain('MB');
-    });
-
-    it('| should handle all size ranges with full format - TB', (): void => {
-      const size = DyFM_Data.terabyte + DyFM_Data.gigabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('TB');
-      expect(result).toContain('GB');
-    });
-
-    it('| should handle all size ranges with full format - PB', (): void => {
-      const size = DyFM_Data.petabyte + DyFM_Data.terabyte * 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('PB');
-      expect(result).toContain('TB');
-    });
-
-    it('| should handle all size ranges with full format - EB', (): void => {
-      const size = DyFM_Data.exabyte + DyFM_Data.petabyte * 512;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('EB');
-      expect(result).toContain('PB');
-    });
-
-    it('| should handle all size ranges with full format - ZB', (): void => {
-      const size = DyFM_Data.zettabyte + DyFM_Data.exabyte * 256;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('ZB');
-      expect(result).toContain('EB');
-    });
-
-    it('| should handle all size ranges with full format - YB', (): void => {
-      const size = DyFM_Data.yottabyte + DyFM_Data.zettabyte * 128;
-      const result = DyFM_Data.getSizeString(size, 0, true);
-      expect(result).toContain('YB');
-      expect(result).toContain('ZB');
-    });
-
-    it('| should handle negative values with full format for all ranges', (): void => {
-      const sizes = [
-        -(DyFM_Data.kilobyte + 512),
-        -(DyFM_Data.megabyte + DyFM_Data.kilobyte * 256),
-        -(DyFM_Data.gigabyte + DyFM_Data.megabyte * 256),
-        -(DyFM_Data.terabyte + DyFM_Data.gigabyte * 256),
-        -(DyFM_Data.petabyte + DyFM_Data.terabyte * 512),
-      ];
-      
-      sizes.forEach(size => {
-        const result = DyFM_Data.getSizeString(size, 0, true);
-        expect(result).toContain('-');
-      });
-    });
-
-    it('| should handle exact boundaries with full format', (): void => {
-      // Test exact unit boundaries with full format
-      const boundaries = [
-        DyFM_Data.kilobyte,
-        DyFM_Data.megabyte,
-        DyFM_Data.gigabyte,
-        DyFM_Data.terabyte,
-        DyFM_Data.petabyte,
-        DyFM_Data.exabyte,
-        DyFM_Data.zettabyte,
-        DyFM_Data.yottabyte,
-      ];
-      
-      boundaries.forEach(size => {
-        const result = DyFM_Data.getSizeString(size, 0, true);
-        expect(result).toMatch(/^\d+(KB|MB|GB|TB|PB|EB|ZB|YB)$/);
-        expect(result).not.toMatch(/\s/); // No space means no remainder
-      });
-    });
-  });
-
-  describe('| constants - all units', (): void => {
-    it('| should have correct petabyte value', (): void => {
-      expect(DyFM_Data.petabyte).toBe(1024 * 1024 * 1024 * 1024 * 1024);
-    });
-
-    it('| should have correct exabyte value', (): void => {
-      expect(DyFM_Data.exabyte).toBe(1024 * 1024 * 1024 * 1024 * 1024 * 1024);
-    });
-
-    it('| should have correct zettabyte value', (): void => {
-      expect(DyFM_Data.zettabyte).toBe(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024);
-    });
-
-    it('| should have correct yottabyte value', (): void => {
-      expect(DyFM_Data.yottabyte).toBe(1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024);
-    });
-  });
-});
-

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

@@ -1,226 +0,0 @@
-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;
-  }
-}
-
-