UPDATE

Author: tamedevelopers

README.md

@@ -7,6 +7,18 @@ Support Package For Tamedevelopers
 * [Installation](#installation)
 * [All Paths](#all-paths)
 * [Number to Words](#number-to-words)
+* [Tame](#tame)
+    * [byteToUnit](#byteToUnit)
+    * [sizeToBytes](#sizeToBytes)
+    * [fileTime](#fileTime)
+    * [exists](#exists)
+    * [unlink](#unlink)
+    * [calPercentageBetweenNumbers](#calPercentageBetweenNumbers)
+    * [formatNumberToNearestThousand](#formatNumberToNearestThousand)
+    * [calculateVolumeWeight](#calculateVolumeWeight)
+    * [calculateCubicMeterWeight](#calculateCubicMeterWeight)
+    * [getBetweenBoxLengthAndWeightInKg](#getBetweenBoxLengthAndWeightInKg)
+    * [getBetweenBoxLengthAndWeightInCMB](#getBetweenBoxLengthAndWeightInCMB)
 * [Zip](#zip)
     * [Unzip](#unzip)
     * [Zip Download](#zip-download)
@@ -120,6 +132,80 @@ NumberToWords::value('twelve million three hundred thousand, six hundred and nin
 // 12300000.698
 ```
 
+## Tame
+- The Core Class of Components
+    - It's helper class can be called as -- `Tame()`
+
+```
+Tamedevelopers\Support\Tame
+
+Tame::fileTime('absolute_path_to_file');
+``` 
+
+### byteToUnit
+- Accepts 5 param. first param alone is needed
+    - All other params are [optional]
+
+| Params    | Description                                   |
+|-----------|-----------------------------------------------|
+| bytes     | The size in bytes to be converted             |
+| format    | Whether to preserve case (default: lowercase) |
+| gb        | Custom label for GB (default: 'GB')           |
+| mb        | Custom label for MB (default: 'MB')           |
+| kb        | Custom label for KB (default: 'KB')           |
+
+```
+Tame()->byteToUnit(6880);
+
+// 7kb
+```
+
+### sizeToBytes
+
+```
+Tame()->sizeToBytes('24mb');
+
+// 25165824
+```
+
+### fileTime
+- Returns last edited time of the file as an - `int|false`
+
+```
+Tame()->fileTime(base_path('filepath.php'));
+```
+
+### exists
+- Checks if a file exists and is not a directory - `bool`
+
+```
+Tame()->exists(base_path('filepath.php'));
+// Output: true or false
+```
+
+### unlink
+- Deletes a file from the server if it exists and does not match the restricted file name - `void`
+    - [optional] second param <filename.extension>
+
+```
+Tame()->unlink(base_path('path/to/directory/avatar.png'), 'default.png');
+```
+
+### calPercentageBetweenNumbers
+- Calculates the percentage relationship between two numbers as an - `int`
+
+```
+Tame()->calPercentageBetweenNumbers(100, 80);
+```
+
+### formatNumberToNearestThousand
+- Formats a number to its nearest thousand, million, billion, or higher as a - `string|float|int`
+
+```
+Tame()->formatNumberToNearestThousand(1500000);
+// Output: "1.5m"
+```
+
 ## Zip
 - Takes two param as `string`
     - [sourcePath] relative path of zip-file

Tame.php

@@ -7,6 +7,7 @@
 use Tamedevelopers\Support\Str;
 use Tamedevelopers\Support\Server;
 use Tamedevelopers\Support\Traits\TameTrait;
+use Tamedevelopers\Support\Traits\NumberToWordsTraits;
 
 /**
  * @see \Tamedevelopers\Support\Str
@@ -15,7 +16,8 @@
  */
 class Tame {
 
-    use TameTrait;
+    use TameTrait, 
+        NumberToWordsTraits;
 
     /**
      * Count
@@ -230,26 +232,34 @@ static public function requireOnce($path)
     /**
      * Convert Bytes to Units 
      *
-     * @param  float|int $bytes
-     * @param  bool $format
-     * @param  string|null $gb
-     * @param  string|null $mb
-     * @param  string|null $kb
+     * @param  int|float $bytes The size in bytes to be converted.
+     * @param  bool $format Whether to preserve case (default: lowercase).
+     * @param  string|null $gb Custom label for GB (default: 'GB').
+     * @param  string|null $mb Custom label for MB (default: 'MB').
+     * @param  string|null $kb Custom label for KB (default: 'KB').
      * 
      * @return string
      */
-    static public function byteToUnit($bytes = 0, $format = true, $gb = 'GB', $mb = 'MB', $kb = 'KB')
+    static public function byteToUnit($bytes = 0, $format = false, $gb = 'GB', $mb = 'MB', $kb = 'KB')
     {
-        $bytes = (int) $bytes;
-        if ($bytes >= 1073741824){
-            $bytes = round(($bytes / 1073741824)) . $gb;
-        } elseif ($bytes >= 1048576){
-            $bytes = round(($bytes / 1048576)) . $mb;
-        } elseif ($bytes >= 1024){
-            $bytes = round(($bytes / 1024)) . $kb;
+        // Define byte thresholds.
+        $units = [
+            'GB' => [1073741824, $gb],
+            'MB' => [1048576, $mb],
+            'KB' => [1024, $kb],
+        ];
+
+        if (!is_numeric($bytes) || $bytes < $units['KB'][0]) {
+            return "{$bytes} {$kb}"; // Handle invalid or negative input.
         }
 
-        return $format ? $bytes : Str::lower($bytes);
+        foreach ($units as $unit => [$threshold, $label]) {
+            if ($bytes >= $threshold) {
+                $value = round($bytes / $threshold) . $label;
+
+                return $format ? $value : Str::lower($value); 
+            }
+        }
     }
 
     /**
@@ -417,7 +427,7 @@ static public function getBetweenBoxLengthAndWeightInKg($length = 0, $width = 0,
     {
         $weight = (float) $weight; 
         $dimensional_weight = self::calculateVolumeWeight($length, $width, $height, $format, $decimal);
-        if($dimensional_weight > $weight){
+        if($dimensional_weight >= $weight){
             return $dimensional_weight;
         }
 
@@ -452,7 +462,7 @@ static public function getBetweenBoxLengthAndWeightInCMB($length = 0, $width = 0
     {
         $weight = (float) $weight; 
         $dimensional_weight = self::calculateCubicMeterWeight($length, $width, $height, $format, $decimal);
-        if($dimensional_weight > $weight){
+        if($dimensional_weight >= $weight){
             return $dimensional_weight;
         }
 
@@ -497,26 +507,28 @@ static public function getBetweenDimensionalWeightAndWeightInCBM(mixed $dimensio
     } 
 
     /**
-     * Round to decimal point
+     * Round a value to the nearest specified decimal.
      * 
-     * @param mixed $value
-     * - float|int
-     * 
-     * @param mixed $decimal
-     * - float|int|string
+     * @param float|int|string $value The value to be rounded.
+     * @param float|int|string $decimal The decimal value for rounding. Default is 0.5.
      * 
-     * @return int
+     * @return int|float
      */
     static public function roundToDecimal(mixed $value = 0, mixed $decimal = 0.5)
     {
+        $value  = (float) $value;
         $decimal = (float) $decimal;
 
-        if($decimal == self::COUNT) $decimal = 0.1;
-        if($value == self::COUNT) return $value; 
+        if($decimal == self::COUNT){
+            $decimal = 0.1;
+        } 
+
+        if($value == self::COUNT){
+            return $value;
+        }
 
-        // Perform the rounding
+        // Perform the rounding calculation
         $result = ceil($value / $decimal) * $decimal;
-        // return round($value / $decimal, 1, PHP_ROUND_HALF_UP) * $decimal;
 
         return round($result, 1);
     }
@@ -571,20 +583,20 @@ static public function gramsToKg(float|int $weight = 0)
     /**
      * Calculation Percentage between numbers  
      *
-     * @param float|int $total
+     * @param float|int $number
      * @param float|int $newNumber
      * @return int
      */
-    static public function calPercentageBetweenNumbers(float|int $total = 0, float|int $newNumber = 0)
+    static public function calPercentageBetweenNumbers(float|int $number = 0, float|int $newNumber = 0)
     {
         // default 
         $decreaseValue = self::COUNT;
 
-        if($total > $newNumber){
-            $decreaseValue = ($newNumber / $total) * 100;
+        if($number > $newNumber){
+            $decreaseValue = ($newNumber / $number) * 100;
         } else{
-            if($total != self::COUNT && $newNumber != self::COUNT){
-                $decreaseValue = ($total / $newNumber) * 100;
+            if($number != self::COUNT && $newNumber != self::COUNT){
+                $decreaseValue = ($number / $newNumber) * 100;
             } elseif($newNumber != self::COUNT){
                 $decreaseValue = ($newNumber * 100) / $newNumber;
             }
@@ -839,32 +851,29 @@ static public function filter_input($string = null)
 
     /**
      * Format number to nearest thousand
-     * @link https://code.recuweb.com/2018/php-format-numbers-to-nearest-thousands/
-     *
      * @param  float|int $number
      * @return void
      */
     static public function formatNumberToNearestThousand(float|int $number = 0)
     {
-        if( $number >= 1000 ) {
-            $x  = round($number);
-            $x_number_format = number_format($x);
-            $x_array = explode(',', $x_number_format);
-
-            //[t(trillion) - p(quadrillion) - e(quintillion) - z(sextillion) - y(septillion)]
-            $x_parts        = array('k', 'm', 'b', 't', 'p', 'e', 'z', 'y');
-            $x_count_parts  = count($x_array) - 1;
-            $x_display      = $x;
-            $x_display      = $x_array[0] . ((int) $x_array[1][0] !== 0 ? '.' . $x_array[1][0] : '');
-            
-            // if amount in array
-            if(in_array($x_count_parts - 1, array_keys($x_parts))){
-                $x_display .= $x_parts[$x_count_parts - 1];
-            }
-            return $x_display;
+        if ($number < 1000) {
+            return $number; // Return the number as is if it's less than 1000.
         }
 
-        return $number;
+        // Define suffixes for each magnitude
+        $suffixes = self::$suffixes;
+
+        // Calculate the magnitude
+        $magnitude  = floor(log($number, 1000)); // Find the magnitude in powers of 1000
+        $suffix     = $suffixes[$magnitude] ?? ''; // Use suffix if it exists, otherwise empty
+
+        // Scale the number down to the appropriate magnitude
+        $scaledNumber = $number / pow(1000, $magnitude);
+
+        // Keep one decimal place only if the scaled number has significant decimals
+        $formattedNumber = floor($scaledNumber * 10) / 10;
+
+        return "{$formattedNumber}{$suffix}";
     }
 
     /**
@@ -883,20 +892,20 @@ static public function exists($path = null)
     /**
      * Unlink File from Server
      *
-     * @param string $pathToFile
+     * @param string $file
      * - [full path to file is required]
      * 
-     * @param string|null $fileName
+     * @param string|null $restrictedfileName
      * - [optional] file name. <avatar.png>
      * 
      * @return void
      */
-    static public function unlink(string $pathToFile, $fileName = null)
+    static public function unlink(string $file, $restrictedfileName = null)
     {
-        $fullPath = self::stringReplacer($pathToFile);
+        $fullPath = self::stringReplacer($file);
 
         if(self::exists($fullPath)){
-            if(basename($fullPath) != basename((string) $fileName)){
+            if(basename($fullPath) != basename((string) $restrictedfileName)){
                 @unlink($fullPath);
             }
         }

Tests/numberToWords.php

@@ -8,7 +8,7 @@
 
     // NumberToWords::cents(true)->iso('nga')->value('4531232221205435349345443534.21')->toText(),
 
-    NumberToWords::iso('FRA')->cents(true)->value('1,000,000,000,000,000,057,857,959,942,726,969,827,393,378,689,175,040,438,172,647,424')->toText(),
+    // NumberToWords::iso('FRA')->cents(true)->value('1000000000000000057857959942726969827393378689175040438172647424')->toText(),
 
     NumberToWords::iso('FRA')->cents(true)->value(34590323.231)->toText(),
 

Tests/tame.php

@@ -0,0 +1,51 @@
+<?php 
+
+use Tamedevelopers\Support\Time;
+
+require_once __DIR__ . '/../vendor/autoload.php';
+
+
+// Tame()->HeadersSent();
+
+$volume = [
+    1 => [
+        'length' => 20,
+        'width' => 10,
+        'height' => 40,
+    ],
+    2 => [
+        'length' => 120,
+        'width' => 87,
+        'height' => 450,
+    ],
+];
+
+$VolumeWeight       = Tame()->calculateVolumeWeight($volume[1]['length'], $volume[1]['width'], $volume[1]['height'], false, 0.5);
+$CubicMeterWeight   = Tame()->calculateCubicMeterWeight($volume[2]['length'], $volume[2]['width'], $volume[2]['height'], false, 0.1);
+
+dd(
+    Tame()->countDivisibleNumbers(100, 680),
+
+    Tame()->byteToUnit(6880),
+
+    Tame()->sizeToBytes('24mb'),
+
+    Tame()->fileTime(base_path('Tests/tame.php')),
+
+    'br',
+
+    $VolumeWeight,
+
+    $CubicMeterWeight,
+
+    Tame()->getBetweenBoxLengthAndWeightInKg(20, 10, 40, $VolumeWeight, true, 0.5),
+    Tame()->getBetweenBoxLengthAndWeightInCMB(20, 10, 40, $CubicMeterWeight),
+
+    Tame()->kgToGrams(2.7),
+
+    Tame()->gramsToKg(2701.0),
+
+    Tame()->calPercentageBetweenNumbers(2701.0, 4320),
+
+    Tame()->formatNumberToNearestThousand(300196366636753),
+); 

Tests/time.php

@@ -44,7 +44,7 @@
     Time::getGlobalTimeZone(),
 
     TameTime()->formatRange('1-14')->get(false, true),
-    TameTime()->dateRange('0-40')->get(true, true),
+    TameTime()->dateRange('0-40')->get(true),
 
     // Time::allTimezone(),