Merge branch 'feat/storage-transfer-units' into chore/all-my-stuffs

# Conflicts:
#	components.d.ts
#	src/tools/index.ts

Author: sharevb

pnpm-lock.yaml

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { convertStorageAndRateUnitsDisplay, displayStorageAndRateUnits } from './data-storage-unit-converter.service';
+
+describe('data-storage-unit-converter', () => {
+  describe('convertStorageAndRateUnitsDisplay', () => {
+    it('convert from same base units', () => {
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024 * 1024, fromUnit: 'B', toUnit: 'MiB' })).toBe('1');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024, fromUnit: 'KiB', toUnit: 'MiB' })).toBe('1');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MiB', toUnit: 'KiB' })).toBe('1024');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'MB', toUnit: 'GB' })).toBe('1');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024, fromUnit: 'MB', toUnit: 'MB' })).toBe('1024');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MB', toUnit: 'KB' })).toBe('1000');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024, fromUnit: 'MiB', toUnit: 'GiB' })).toBe('1');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'MB', toUnit: 'GB' })).toBe('1');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'Mb', toUnit: 'Gb' })).toBe('1');
+    });
+
+    it('convert between base units', () => {
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MB', toUnit: 'MiB' })).toBe('0.954');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MiB', toUnit: 'MB' })).toBe('1.049');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000 * 1000, fromUnit: 'B', toUnit: 'MiB' })).toBe('0.954');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024, fromUnit: 'KB', toUnit: 'MiB' })).toBe('0.977');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'MiB', toUnit: 'MB' })).toBe('1048.576');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MB', toUnit: 'Mb' })).toBe('8');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'KB', toUnit: 'Kb' })).toBe('8000');
+      expect(convertStorageAndRateUnitsDisplay({ value: 1000, fromUnit: 'KiB', toUnit: 'Kb' })).toBe('8192');
+      expect(convertStorageAndRateUnitsDisplay({ value: 8, fromUnit: 'Mb', toUnit: 'MB' })).toBe('1');
+
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'Mb', toUnit: 'KB' })).toBe('125');
+      expect(convertStorageAndRateUnitsDisplay({ value: 125, fromUnit: 'KB', toUnit: 'Mb' })).toBe('1');
+
+      expect(convertStorageAndRateUnitsDisplay({ value: 1, fromUnit: 'MiB', toUnit: 'Kb' })).toBe('8388.608');
+      expect(convertStorageAndRateUnitsDisplay({ value: 8388.608, fromUnit: 'Kb', toUnit: 'MiB' })).toBe('1');
+    });
+    it('convert with unit display', () => {
+      expect(convertStorageAndRateUnitsDisplay({ value: 1024 * 1024, fromUnit: 'B', toUnit: 'MiB', appendUnit: true })).toBe('1MiB');
+    });
+
+    //
+  });
+  describe('displayStorageAndRateUnits', () => {
+    it('convert to correct display value', () => {
+      expect(displayStorageAndRateUnits({
+        value: 1.234567, unit: 'MB', appendUnit: false,
+      })).toBe('1.235');
+      expect(displayStorageAndRateUnits({
+        value: 1.234567, unit: 'MB', appendUnit: true,
+      })).toBe('1.235MB');
+      expect(displayStorageAndRateUnits({
+        value: 1.234567, unit: 'MB', appendUnit: true, precision: 5,
+      })).toBe('1.23457MB');
+    });
+  });
+});

src/tools/data-storage-unit-converter/data-storage-unit-converter.service.test.ts

@@ -0,0 +1,45 @@
+export type BibytesUnits = 'iB' | 'KiB' | 'MiB' | 'GiB' | 'TiB' | 'PiB' | 'EiB' | 'ZiB' | 'YiB';
+export type BytesUnits = 'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+export type BitsUnits = 'b' | 'Kb' | 'Mb' | 'Gb' | 'Tb' | 'Pb' | 'Eb' | 'Zb' | 'Yb';
+export type AllSupportedUnits = BibytesUnits | BytesUnits | BitsUnits;
+
+export function displayStorageAndRateUnits(
+  { value, unit, precision = 3, appendUnit = false }:
+  { value: number; unit: AllSupportedUnits; precision?: number ; appendUnit?: boolean }): string {
+  return value.toFixed(precision).replace(/0+$/, '').replace(/\.$/, '') + (appendUnit ? unit : ''); // NOSONAR
+}
+
+export function convertStorageAndRateUnitsDisplay(
+  { value, fromUnit, toUnit, precision = 3, appendUnit = false }:
+  { value: number; fromUnit: AllSupportedUnits; toUnit: AllSupportedUnits; precision?: number; appendUnit?: boolean }): string {
+  return displayStorageAndRateUnits({
+    precision,
+    unit: toUnit,
+    appendUnit,
+    value: convertStorageAndRateUnits({
+      value, fromUnit, toUnit,
+    }),
+  });
+}
+
+export function convertStorageAndRateUnits(
+  { value, fromUnit, toUnit }:
+  { value: number; fromUnit: AllSupportedUnits; toUnit: AllSupportedUnits }): number {
+  const units = [
+    'iB', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB',
+    'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB',
+    'b', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb',
+  ];
+
+  const fromIndex = units.indexOf(fromUnit);
+  const fromFactor = fromIndex / 9 > 1 ? 1000 : 1024;
+  const fromDivisor = fromIndex / 9 > 2 ? 8 : 1;
+  const toIndex = units.indexOf(toUnit);
+  const toFactor = toIndex / 9 > 1 ? 1000 : 1024;
+  const toDivisor = toIndex / 9 > 2 ? 8 : 1;
+
+  const fromBase = (fromFactor ** (fromIndex % 9)) / fromDivisor;
+  const toBase = (toFactor ** (toIndex % 9)) / toDivisor;
+
+  return value * fromBase / toBase;
+}

src/tools/data-storage-unit-converter/data-storage-unit-converter.service.ts

@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import InputCopyable from '../../components/InputCopyable.vue';
+import { type AllSupportedUnits, convertStorageAndRateUnitsDisplay } from './data-storage-unit-converter.service';
+
+const input = ref<{ size: string; unit: string }>({ size: '0', unit: 'KB' });
+const output = ref<{ unit: string; precision: number; appendUnit: boolean }>({ unit: 'MB', precision: 3, appendUnit: false });
+
+const allUnits = [
+  { value: 'B', label: 'Bytes (B)' },
+  { value: 'b', label: 'Bits (bit)' },
+  { value: 'iB', label: 'Bibytes (iB)' },
+  { value: 'KB', label: 'Kilobytes (KB)' },
+  { value: 'Kb', label: 'Kilobits (Kbit)' },
+  { value: 'KiB', label: 'Kibibytes (KiB)' },
+  { value: 'MB', label: 'Megabytes (MB)' },
+  { value: 'Mb', label: 'Megabits (Mbit)' },
+  { value: 'MiB', label: 'Mebibytes (MiB)' },
+  { value: 'GB', label: 'Gigabytes (GB)' },
+  { value: 'Gb', label: 'Gigabits (Gbit)' },
+  { value: 'GiB', label: 'Gibibytes (GiB)' },
+  { value: 'TB', label: 'Terabytes (TB)' },
+  { value: 'Tb', label: 'Terabits (Tbit)' },
+  { value: 'TiB', label: 'Tebibytes (TiB)' },
+  { value: 'PB', label: 'Petabytes (PB)' },
+  { value: 'Pb', label: 'Petabits (Pbit)' },
+  { value: 'PiB', label: 'Pebibytes (PiB)' },
+  { value: 'EB', label: 'Exabytes (EB)' },
+  { value: 'Eb', label: 'Exabits (Ebit)' },
+  { value: 'EiB', label: 'Exbibytes (EiB)' },
+  { value: 'ZB', label: 'Zettabytes (ZB)' },
+  { value: 'Zb', label: 'Zettabits (Zbit)' },
+  { value: 'ZiB', label: 'Zebibytes (ZiB)' },
+  { value: 'YB', label: 'Yottabytes (YB)' },
+  { value: 'Yb', label: 'Yottabits (Ybit)' },
+  { value: 'YiB', label: 'Yobibytes (YiB)' },
+];
+
+const convertedValue = computed(() => {
+  try {
+    return convertStorageAndRateUnitsDisplay({
+      value: Number(input.value.size),
+      fromUnit: input.value.unit as AllSupportedUnits,
+      toUnit: output.value.unit as AllSupportedUnits,
+      precision: output.value.precision,
+      appendUnit: output.value.appendUnit,
+    });
+  }
+  catch (e: any) {
+    return e.toString();
+  }
+});
+</script>
+
+<template>
+  <div>
+    <c-card>
+      <n-form-item label="Input Size:" label-placement="left" mb-1>
+        <c-input-text
+          v-model:value="input.size"
+          placeholder="Put your number here (ex: 1024)"
+          mr-2
+        />
+        <c-select
+          v-model:value="input.unit"
+          :options="allUnits"
+          placeholder="Select input unit"
+        />
+      </n-form-item>
+
+      <div flex items-baseline gap-2>
+        <c-select
+          v-model:value="output.unit"
+          label="Output:" label-position="left"
+          :options="allUnits"
+          placeholder="Select output unit"
+        />
+
+        <n-form-item label="Precision:" label-placement="left">
+          <n-input-number v-model:value="output.precision" style="width:100px" placeholder="Precision..." :max="10" :min="0" />
+        </n-form-item>
+
+        <n-checkbox v-model:checked="output.appendUnit">
+          Show unit?
+        </n-checkbox>
+      </div>
+
+      <n-divider />
+
+      <InputCopyable
+        label="Output value"
+        :value="convertedValue"
+        placeholder="Output value will be here..."
+      />
+    </c-card>
+  </div>
+</template>

src/tools/data-storage-unit-converter/data-storage-unit-converter.vue

@@ -0,0 +1,16 @@
+import { ArrowsLeftRight } from '@vicons/tabler';
+import { defineTool } from '../tool';
+
+export const tool = defineTool({
+  name: 'Data Storage Unit converter',
+  path: '/data-storage-unit-converter',
+  description: 'Convert data storage or transfer units (bytes, bibytes, bits, kilobytes...)',
+  keywords: ['data', 'storage', 'unit', 'conversion',
+    'bits', 'bytes', 'bibytes', 'binary',
+    'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB',
+    'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB',
+    'b', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb'],
+  component: () => import('./data-storage-unit-converter.vue'),
+  icon: ArrowsLeftRight,
+  createdAt: new Date('2024-08-15'),
+});

src/tools/data-storage-unit-converter/index.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { amountTransferable, neededRate, transferTimeSeconds } from './data-transfer-rate-converter.service';
+
+describe('data-transfer-converter', () => {
+  describe('transferTimeSeconds', () => {
+    it('compute transfer time in seconds', () => {
+      expect(transferTimeSeconds({
+        dataSize: 100,
+        dataSizeUnit: 'MB',
+        bitRate: 10,
+        bitRateUnit: 'Mb',
+      })).toBe(80);
+    });
+  });
+  describe('neededRate', () => {
+    it('compute neededRate', () => {
+      expect(neededRate({
+        dataSize: 100,
+        dataSizeUnit: 'MB',
+        hours: 0,
+        minutes: 1,
+        seconds: 20,
+        bitRateUnit: 'Mb',
+      })).toBe(10);
+    });
+  });
+  describe('amountTransferable', () => {
+    it('compute amount transfered', () => {
+      expect(amountTransferable({
+        bitRate: 10,
+        bitRateUnit: 'Mb',
+        hours: 1,
+        minutes: 0,
+        seconds: 0,
+        dataSizeUnit: 'MB',
+      })).toBe(4500);
+    });
+  });
+});

src/tools/data-transfer-rate-converter/data-transfer-rate-converter.service.test.ts

@@ -0,0 +1,57 @@
+import { type AllSupportedUnits, type BitsUnits, convertStorageAndRateUnits } from '../data-storage-unit-converter/data-storage-unit-converter.service';
+
+export function transferTimeSeconds({
+  dataSize,
+  dataSizeUnit,
+  bitRate,
+  bitRateUnit,
+}: {
+  dataSize: number
+  dataSizeUnit: AllSupportedUnits
+  bitRate: number
+  bitRateUnit: BitsUnits
+}): number {
+  const dataSizeInBytes = convertStorageAndRateUnits({ value: dataSize, fromUnit: dataSizeUnit, toUnit: 'B' });
+  const bitRateInBytes = convertStorageAndRateUnits({ value: bitRate, fromUnit: bitRateUnit, toUnit: 'B' });
+  return bitRateInBytes > 0 ? dataSizeInBytes / bitRateInBytes : 0;
+}
+
+export function neededRate({
+  dataSize,
+  dataSizeUnit,
+  hours,
+  minutes,
+  seconds,
+  bitRateUnit,
+}: {
+  dataSize: number
+  dataSizeUnit: AllSupportedUnits
+  hours: number
+  minutes: number
+  seconds: number
+  bitRateUnit: BitsUnits
+}): number {
+  const dataSizeInBits = convertStorageAndRateUnits({ value: dataSize, fromUnit: dataSizeUnit, toUnit: 'b' });
+  const timeInSeconds = hours * 3600 + minutes * 60 + seconds;
+  return convertStorageAndRateUnits({ value: timeInSeconds > 0 ? dataSizeInBits / timeInSeconds : 0, fromUnit: 'b', toUnit: bitRateUnit });
+}
+
+export function amountTransferable({
+  bitRate,
+  bitRateUnit,
+  hours,
+  minutes,
+  seconds,
+  dataSizeUnit,
+}: {
+  bitRate: number
+  bitRateUnit: BitsUnits
+  hours: number
+  minutes: number
+  seconds: number
+  dataSizeUnit: AllSupportedUnits
+}): number {
+  const bitRateInBytes = convertStorageAndRateUnits({ value: bitRate, fromUnit: bitRateUnit, toUnit: 'B' });
+  const timeInSeconds = hours * 3600 + minutes * 60 + seconds;
+  return convertStorageAndRateUnits({ value: bitRateInBytes * timeInSeconds, fromUnit: 'B', toUnit: dataSizeUnit });
+}