@futdevpro/fsm-dynamo 1.16.37 → 1.16.39

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

@@ -1,94 +1,94 @@
-
-import { DyFM_Math } from './math.util';
-
-describe('| DyFM_Math', () => {
-
-  describe('| between', () => {
-    it('| should return true if value is between minExclusive and maxExclusive', () => {
-      expect(DyFM_Math.between(5, 1, 10)).toBeTrue();
-    });
-
-    it('| should return false if value is equal to minExclusive', () => {
-      expect(DyFM_Math.between(1, 1, 10)).toBeFalse();
-    });
-
-    it('| should return false if value is equal to maxExclusive', () => {
-      expect(DyFM_Math.between(10, 1, 10)).toBeFalse();
-    });
-
-    it('| should return false if value is outside the range', () => {
-      expect(DyFM_Math.between(0, 1, 10)).toBeFalse();
-      expect(DyFM_Math.between(11, 1, 10)).toBeFalse();
-    });
-  });
-
-  describe('| around', () => {
-    xit('should return true if value is within the range of target', () => {
-      expect(DyFM_Math.around(5, 5, 0)).toBeTrue();
-      expect(DyFM_Math.around(5, 5, 1)).toBeTrue();
-      expect(DyFM_Math.around(4, 5, 1)).toBeTrue();
-      expect(DyFM_Math.around(6, 5, 1)).toBeTrue();
-    });
-
-    it('| should return false if value is outside the range of target', () => {
-      expect(DyFM_Math.around(3, 5, 1)).toBeFalse();
-      expect(DyFM_Math.around(7, 5, 1)).toBeFalse();
-    });
-  });
-
-  describe('| round', () => {
-    it('| should round a number to the specified number of decimals', () => {
-      expect(DyFM_Math.round(1.2345, 2)).toBe(1.23);
-      expect(DyFM_Math.round(1.2355, 2)).toBe(1.24);
-    });
-
-    it('| should round a number to the nearest integer if decimals is 0', () => {
-      expect(DyFM_Math.round(1.5, 0)).toBe(2);
-      expect(DyFM_Math.round(1.4, 0)).toBe(1);
-    });
-
-    it('| should round a number to the nearest multiple of 10 if decimals is negative', () => {
-      expect(DyFM_Math.round(123, -1)).toBe(120);
-      expect(DyFM_Math.round(125, -1)).toBe(130);
-    });
-  });
-
-  describe('| numberWithSpaces', () => {
-    it('| should format a number with spaces as thousand separators', () => {
-      expect(DyFM_Math.numberWithSpaces(1000)).toBe('1 000');
-      expect(DyFM_Math.numberWithSpaces(1000000)).toBe('1 000 000');
-    });
-  });
-
-  describe('| numberWithShorters', () => {
-    it('| should format a number with k, M, or B as appropriate', () => {
-      expect(DyFM_Math.numberWithShorters(999)).toBe('999');
-      expect(DyFM_Math.numberWithShorters(1000)).toBe('1.0k');
-      expect(DyFM_Math.numberWithShorters(1000000)).toBe('1.00M');
-      expect(DyFM_Math.numberWithShorters(1000000000)).toBe('1.000B');
-    });
-  });
-
-  describe('| numberWithShortersAndSpaces', () => {
-    it('| should format a number with shorters and spaces', () => {
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000)).toBe('1.0k');
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000000)).toBe('1.00M');
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000000000)).toBe('1.000B');
-    });
-  });
-
-  describe('| floatingNumberWithSpaces', () => {
-    it('| should format a floating number with spaces as thousand separators', () => {
-      expect(DyFM_Math.floatingNumberWithSpaces(1234.567)).toBe('1 234.567');
-      expect(DyFM_Math.floatingNumberWithSpaces(1234567.89)).toBe('1 234 567.89');
-    });
-  });
-
-  describe('| decimals', () => {
-    it('| should format a number with a custom spacer', () => {
-      expect(DyFM_Math.decimals(1234.567, ',')).toBe('1,234.567');
-      expect(DyFM_Math.decimals(1234567.89, '.')).toBe('1.234.567.89');
-    });
-  });
-
-});
+
+import { DyFM_Math } from './math.util';
+
+describe('| DyFM_Math', () => {
+
+  describe('| between', () => {
+    it('| should return true if value is between minExclusive and maxExclusive', () => {
+      expect(DyFM_Math.between(5, 1, 10)).toBeTrue();
+    });
+
+    it('| should return false if value is equal to minExclusive', () => {
+      expect(DyFM_Math.between(1, 1, 10)).toBeFalse();
+    });
+
+    it('| should return false if value is equal to maxExclusive', () => {
+      expect(DyFM_Math.between(10, 1, 10)).toBeFalse();
+    });
+
+    it('| should return false if value is outside the range', () => {
+      expect(DyFM_Math.between(0, 1, 10)).toBeFalse();
+      expect(DyFM_Math.between(11, 1, 10)).toBeFalse();
+    });
+  });
+
+  describe('| around', () => {
+    xit('should return true if value is within the range of target', () => {
+      expect(DyFM_Math.around(5, 5, 0)).toBeTrue();
+      expect(DyFM_Math.around(5, 5, 1)).toBeTrue();
+      expect(DyFM_Math.around(4, 5, 1)).toBeTrue();
+      expect(DyFM_Math.around(6, 5, 1)).toBeTrue();
+    });
+
+    it('| should return false if value is outside the range of target', () => {
+      expect(DyFM_Math.around(3, 5, 1)).toBeFalse();
+      expect(DyFM_Math.around(7, 5, 1)).toBeFalse();
+    });
+  });
+
+  describe('| round', () => {
+    it('| should round a number to the specified number of decimals', () => {
+      expect(DyFM_Math.round(1.2345, 2)).toBe(1.23);
+      expect(DyFM_Math.round(1.2355, 2)).toBe(1.24);
+    });
+
+    it('| should round a number to the nearest integer if decimals is 0', () => {
+      expect(DyFM_Math.round(1.5, 0)).toBe(2);
+      expect(DyFM_Math.round(1.4, 0)).toBe(1);
+    });
+
+    it('| should round a number to the nearest multiple of 10 if decimals is negative', () => {
+      expect(DyFM_Math.round(123, -1)).toBe(120);
+      expect(DyFM_Math.round(125, -1)).toBe(130);
+    });
+  });
+
+  describe('| numberWithSpaces', () => {
+    it('| should format a number with spaces as thousand separators', () => {
+      expect(DyFM_Math.numberWithSpaces(1000)).toBe('1 000');
+      expect(DyFM_Math.numberWithSpaces(1000000)).toBe('1 000 000');
+    });
+  });
+
+  describe('| numberWithShorters', () => {
+    it('| should format a number with k, M, or B as appropriate', () => {
+      expect(DyFM_Math.numberWithShorters(999)).toBe('999');
+      expect(DyFM_Math.numberWithShorters(1000)).toBe('1.0k');
+      expect(DyFM_Math.numberWithShorters(1000000)).toBe('1.00M');
+      expect(DyFM_Math.numberWithShorters(1000000000)).toBe('1.000B');
+    });
+  });
+
+  describe('| numberWithShortersAndSpaces', () => {
+    it('| should format a number with shorters and spaces', () => {
+      expect(DyFM_Math.numberWithShortersAndSpaces(1000)).toBe('1.0k');
+      expect(DyFM_Math.numberWithShortersAndSpaces(1000000)).toBe('1.00M');
+      expect(DyFM_Math.numberWithShortersAndSpaces(1000000000)).toBe('1.000B');
+    });
+  });
+
+  describe('| floatingNumberWithSpaces', () => {
+    it('| should format a floating number with spaces as thousand separators', () => {
+      expect(DyFM_Math.floatingNumberWithSpaces(1234.567)).toBe('1 234.567');
+      expect(DyFM_Math.floatingNumberWithSpaces(1234567.89)).toBe('1 234 567.89');
+    });
+  });
+
+  describe('| decimals', () => {
+    it('| should format a number with a custom spacer', () => {
+      expect(DyFM_Math.decimals(1234.567, ',')).toBe('1,234.567');
+      expect(DyFM_Math.decimals(1234567.89, '.')).toBe('1.234.567.89');
+    });
+  });
+
+});

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

@@ -1,141 +1,141 @@
-
-
-
-/**
- * this class is a collection of static methods for mathematical operations
- */
-export class DyFM_Math {
-
-  /**
-   * returns true if the value is between the min and max
-   * 
-   * @example
-   * ```ts
-   * const isBetween = DyFM_Math.between(5, 1, 10);
-   * console.log(isBetween);
-   * ```
-   */
-  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
-    return minExclusive < value && value < maxExclusive;
-  }
-
-  /**
-   * returns true if the value is between the target and the range
-   * 
-   * @example
-   * ```ts
-   * const isAround = DyFM_Math.around(5, 5, 1);
-   * console.log(isAround);
-   * ```
-   */
-  static around(value: number, target: number, range: number): boolean {
-    return this.between(value, target - range, target + range);
-  }
-
-  static readonly toFixed = this.round;
-  /**
-   * returns a number rounded to the specified number of decimals
-   * 
-   * @example
-   * ```ts
-   * const roundedNumber = DyFM_Math.round(1.2345, 2);
-   * console.log(roundedNumber); // 1.23
-   * ```
-   */
-  static round(value: number, decimals: number = 2): number {
-    if (0 <= decimals) {
-      return Number(value.toFixed(decimals));
-    } else {
-      const factor = Math.pow(10, -decimals);
-      
-      return Math.round(value / factor) * factor;
-    }
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const numberWithSpaces = DyFM_Math.numberWithSpaces(1000);
-   * console.log(numberWithSpaces); // '1 000'
-   * ```
-   */
-  static numberWithSpaces(x: number): string {
-    return x?.toString()?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  }
-
-  /**
-   * returns a number with shorter units
-   * 
-   * @example
-   * ```ts
-   * const numberWithShorters = DyFM_Math.numberWithShorters(1000);
-   * console.log(numberWithShorters); // '1.0k'
-   * ```
-   */
-  static numberWithShorters(x: number): string {
-    if (x < 1000) {
-      return x?.toString();
-    } else if (x < 1000000) {
-      return (x / 1000)?.toFixed(1) + 'k';
-    } else if (x < 1000000000) {
-      return (x / 1000000)?.toFixed(2) + 'M';
-    } else {
-      return (x / 1000000000)?.toFixed(3) + 'B';
-    }
-  }
-
-  /**
-   * returns a number with shorter units and spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const numberWithShortersAndSpaces = DyFM_Math.numberWithShortersAndSpaces(1000);
-   * console.log(numberWithShortersAndSpaces); // '1.0k'
-   * ```
-   */
-  static numberWithShortersAndSpaces(x: number): string {
-    return this.numberWithShorters(x)?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const floatingNumberWithSpaces = DyFM_Math.floatingNumberWithSpaces(1234.567);
-   * console.log(floatingNumberWithSpaces); // '1 234.567'
-   * ```
-   */
-  static floatingNumberWithSpaces(x: number): string {
-    const parts: string[] = x?.toString()?.split('.');
-
-    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-
-    return parts?.join('.');
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const decimals = DyFM_Math.decimals(1234.567, ',');
-   * console.log(decimals); // '1,234.567'
-   * ```
-   */
-  static decimals(x: number, useSpacer: string = ','): string {
-    const parts: string[] = x?.toString()?.split('.');
-
-    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
-
-    return parts?.join('.');
-  }
-}
-
-
-
-
-
-
+
+
+
+/**
+ * this class is a collection of static methods for mathematical operations
+ */
+export class DyFM_Math {
+
+  /**
+   * returns true if the value is between the min and max
+   * 
+   * @example
+   * ```ts
+   * const isBetween = DyFM_Math.between(5, 1, 10);
+   * console.log(isBetween);
+   * ```
+   */
+  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
+    return minExclusive < value && value < maxExclusive;
+  }
+
+  /**
+   * returns true if the value is between the target and the range
+   * 
+   * @example
+   * ```ts
+   * const isAround = DyFM_Math.around(5, 5, 1);
+   * console.log(isAround);
+   * ```
+   */
+  static around(value: number, target: number, range: number): boolean {
+    return this.between(value, target - range, target + range);
+  }
+
+  static readonly toFixed = this.round;
+  /**
+   * returns a number rounded to the specified number of decimals
+   * 
+   * @example
+   * ```ts
+   * const roundedNumber = DyFM_Math.round(1.2345, 2);
+   * console.log(roundedNumber); // 1.23
+   * ```
+   */
+  static round(value: number, decimals: number = 2): number {
+    if (0 <= decimals) {
+      return Number(value.toFixed(decimals));
+    } else {
+      const factor = Math.pow(10, -decimals);
+      
+      return Math.round(value / factor) * factor;
+    }
+  }
+
+  /**
+   * returns a number with spaces between the thousands
+   * 
+   * @example
+   * ```ts
+   * const numberWithSpaces = DyFM_Math.numberWithSpaces(1000);
+   * console.log(numberWithSpaces); // '1 000'
+   * ```
+   */
+  static numberWithSpaces(x: number): string {
+    return x?.toString()?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  }
+
+  /**
+   * returns a number with shorter units
+   * 
+   * @example
+   * ```ts
+   * const numberWithShorters = DyFM_Math.numberWithShorters(1000);
+   * console.log(numberWithShorters); // '1.0k'
+   * ```
+   */
+  static numberWithShorters(x: number): string {
+    if (x < 1000) {
+      return x?.toString();
+    } else if (x < 1000000) {
+      return (x / 1000)?.toFixed(1) + 'k';
+    } else if (x < 1000000000) {
+      return (x / 1000000)?.toFixed(2) + 'M';
+    } else {
+      return (x / 1000000000)?.toFixed(3) + 'B';
+    }
+  }
+
+  /**
+   * returns a number with shorter units and spaces between the thousands
+   * 
+   * @example
+   * ```ts
+   * const numberWithShortersAndSpaces = DyFM_Math.numberWithShortersAndSpaces(1000);
+   * console.log(numberWithShortersAndSpaces); // '1.0k'
+   * ```
+   */
+  static numberWithShortersAndSpaces(x: number): string {
+    return this.numberWithShorters(x)?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  }
+
+  /**
+   * returns a number with spaces between the thousands
+   * 
+   * @example
+   * ```ts
+   * const floatingNumberWithSpaces = DyFM_Math.floatingNumberWithSpaces(1234.567);
+   * console.log(floatingNumberWithSpaces); // '1 234.567'
+   * ```
+   */
+  static floatingNumberWithSpaces(x: number): string {
+    const parts: string[] = x?.toString()?.split('.');
+
+    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+
+    return parts?.join('.');
+  }
+
+  /**
+   * returns a number with spaces between the thousands
+   * 
+   * @example
+   * ```ts
+   * const decimals = DyFM_Math.decimals(1234.567, ',');
+   * console.log(decimals); // '1,234.567'
+   * ```
+   */
+  static decimals(x: number, useSpacer: string = ','): string {
+    const parts: string[] = x?.toString()?.split('.');
+
+    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
+
+    return parts?.join('.');
+  }
+}
+
+
+
+
+
+

package/src/_collections/utils/math/random.util.spec.ts

@@ -1,82 +1,82 @@
-
-import { DyFM_Random } from './random.util';
-import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
-
-describe('| DyFM_Random', () => {
-  describe('| getRandomWeightedInt', () => {
-    it('| should return a weighted random integer within the range', () => {
-      const weights: DyFM_RandomWeight<number>[] = [
-        { chance: 0.1, result: 1 },
-        { chance: 0.3, result: 2 },
-        { chance: 0.6, result: 3 }
-      ];
-      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
-      expect(result).toBeGreaterThanOrEqual(1);
-      expect(result).toBeLessThanOrEqual(3);
-    });
-
-    it('| should normalize weights if their sum is greater than 1', () => {
-      const weights: DyFM_RandomWeight<number>[] = [
-        { chance: 0.5, result: 1 },
-        { chance: 0.5, result: 2 },
-        { chance: 0.5, result: 3 }
-      ];
-      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
-      expect(result).toBeGreaterThanOrEqual(1);
-      expect(result).toBeLessThanOrEqual(3);
-    });
-
-    it('| should return a random integer within the range if no weights match', () => {
-      const weights: DyFM_RandomWeight<number>[] = [
-        { chance: 0, result: 1 },
-        { chance: 0, result: 2 },
-        { chance: 0, result: 3 }
-      ];
-      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
-      expect(result).toBeGreaterThanOrEqual(1);
-      expect(result).toBeLessThanOrEqual(3);
-    });
-  });
-
-  describe('| getRandomInt', () => {
-    it('| should return a random integer within the specified range', () => {
-      const min = 5;
-      const max = 10;
-      const result = DyFM_Random.getRandomInt(min, max);
-      expect(result).toBeGreaterThanOrEqual(min);
-      expect(result).toBeLessThanOrEqual(max);
-    });
-  });
-
-  describe('| getRandomListElement', () => {
-    it('| should return a random element from the list', () => {
-      const list: number[] = [1, 2, 3, 4, 5];
-      const result: number | null = DyFM_Random.getRandomListElement(list);
-      expect(list).toContain(result as number);
-    });
-
-    it('| should return null if the list is empty', () => {
-      const list: number[] = [];
-      const result: number | null = DyFM_Random.getRandomListElement(list);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('| getRandomWeighted', () => {
-    it('| should return a weighted random element', () => {
-      const weights: DyFM_RandomWeight<string>[] = [
-        { chance: 0.2, result: 'a' },
-        { chance: 0.5, result: 'b' },
-        { chance: 0.3, result: 'c' }
-      ];
-      const result: string | null = DyFM_Random.getRandomWeighted(weights);
-      expect(['a', 'b', 'c']).toContain(result as string);
-    });
-
-    it('| should return null if weights array is empty', () => {
-      const weights: DyFM_RandomWeight<string>[] = [];
-      const result: string | null = DyFM_Random.getRandomWeighted(weights);
-      expect(result).toBeNull();
-    });
-  });
-});
+
+import { DyFM_Random } from './random.util';
+import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
+
+describe('| DyFM_Random', () => {
+  describe('| getRandomWeightedInt', () => {
+    it('| should return a weighted random integer within the range', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0.1, result: 1 },
+        { chance: 0.3, result: 2 },
+        { chance: 0.6, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+
+    it('| should normalize weights if their sum is greater than 1', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0.5, result: 1 },
+        { chance: 0.5, result: 2 },
+        { chance: 0.5, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+
+    it('| should return a random integer within the range if no weights match', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0, result: 1 },
+        { chance: 0, result: 2 },
+        { chance: 0, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+  });
+
+  describe('| getRandomInt', () => {
+    it('| should return a random integer within the specified range', () => {
+      const min = 5;
+      const max = 10;
+      const result = DyFM_Random.getRandomInt(min, max);
+      expect(result).toBeGreaterThanOrEqual(min);
+      expect(result).toBeLessThanOrEqual(max);
+    });
+  });
+
+  describe('| getRandomListElement', () => {
+    it('| should return a random element from the list', () => {
+      const list: number[] = [1, 2, 3, 4, 5];
+      const result: number | null = DyFM_Random.getRandomListElement(list);
+      expect(list).toContain(result as number);
+    });
+
+    it('| should return null if the list is empty', () => {
+      const list: number[] = [];
+      const result: number | null = DyFM_Random.getRandomListElement(list);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('| getRandomWeighted', () => {
+    it('| should return a weighted random element', () => {
+      const weights: DyFM_RandomWeight<string>[] = [
+        { chance: 0.2, result: 'a' },
+        { chance: 0.5, result: 'b' },
+        { chance: 0.3, result: 'c' }
+      ];
+      const result: string | null = DyFM_Random.getRandomWeighted(weights);
+      expect(['a', 'b', 'c']).toContain(result as string);
+    });
+
+    it('| should return null if weights array is empty', () => {
+      const weights: DyFM_RandomWeight<string>[] = [];
+      const result: string | null = DyFM_Random.getRandomWeighted(weights);
+      expect(result).toBeNull();
+    });
+  });
+});