feat: add length conversion metres to feet and vice versa

Conversions/LengthConversion.js

@@ -1,36 +1,33 @@
 /**
- * Converts a length from one unit to another.
- *
- * @param {number} length - The length to convert.
- * @param {string} fromUnit - The unit to convert from (e.g., "km", "m", "cm").
- * @param {string} toUnit - The unit to convert to (e.g., "km", "m", "cm").
- * @returns {number} The converted length.
- * @throws {Error} If the units are invalid or not found in the conversion dictionary.
+ * @function metresToFeet
+ * @description Converts length from metres to feet.
+ * @param {number} metres - Length in metres
+ * @returns {number} - Length in feet
+ * @see https://en.wikipedia.org/wiki/Foot_(unit)
+ * @example metresToFeet(1) => 3.28084
+ * @example metresToFeet(10) => 32.8084
  */
-
-const lengthConversion = (length, fromUnit, toUnit) => {
-  // Define a dictionary to map units to meters
-  const meters = {
-    mm: 0.001,
-    cm: 0.01,
-    m: 1,
-    km: 1000,
-    inch: 0.0254,
-    ft: 0.3048,
-    yd: 0.9144,
-    mi: 1609.34
+const metresToFeet = (metres) => {
+  if (typeof metres !== 'number' || isNaN(metres)) {
+    throw new TypeError('Input must be a number')
   }
+  return metres * 3.28084
+}
 
-  // Check if the units are in the dictionary, otherwise, throw an error
-  if (!(fromUnit in meters) || !(toUnit in meters)) {
-    throw new Error('Invalid units')
+/**
+ * @function feetToMetres
+ * @description Converts length from feet to metres.
+ * @param {number} feet - Length in feet
+ * @returns {number} - Length in metres
+ * @see https://en.wikipedia.org/wiki/Metre
+ * @example feetToMetres(1) => 0.3048
+ * @example feetToMetres(10) => 3.048
+ */
+const feetToMetres = (feet) => {
+  if (typeof feet !== 'number' || isNaN(feet)) {
+    throw new TypeError('Input must be a number')
   }
-
-  // Perform the conversion
-  const metersFrom = length * meters[fromUnit]
-  const convertedLength = metersFrom / meters[toUnit]
-
-  return convertedLength
+  return feet * 0.3048
 }
 
-export { lengthConversion }
+export { metresToFeet, feetToMetres }

Conversions/test/LengthConversion.test.js

@@ -1,53 +1,53 @@
-import { lengthConversion } from '../LengthConversion.js'
-
-describe('LengthConversion', () => {
-  it.each`
-    length | fromUnit | toUnit    | expected
-    ${10}  | ${'km'}  | ${'m'}    | ${10000}
-    ${100} | ${'m'}   | ${'km'}   | ${0.1}
-    ${5}   | ${'cm'}  | ${'mm'}   | ${50}
-    ${12}  | ${'ft'}  | ${'inch'} | ${144.00000000000003}
-  `(
-    'converts $length $fromUnit to $toUnit',
-    ({ length, fromUnit, toUnit, expected }) => {
-      try {
-        const result = lengthConversion(length, fromUnit, toUnit)
-        expect(result).toBe(expected)
-      } catch (error) {
-        expect(error).toBeUndefined()
-      }
-    }
-  )
-
-  it.each`
-    length  | fromUnit  | toUnit  | expected
-    ${10}   | ${'m'}    | ${'km'} | ${0.01}
-    ${1000} | ${'mm'}   | ${'cm'} | ${100}
-    ${1}    | ${'inch'} | ${'ft'} | ${0.08333333333}
-  `(
-    'converts $length $fromUnit to $toUnit (vice versa)',
-    ({ length, fromUnit, toUnit, expected }) => {
-      try {
-        const result = lengthConversion(length, fromUnit, toUnit)
-        expect(result).toBeCloseTo(expected, 10) // Close comparison due to floating-point precision
-      } catch (error) {
-        expect(error).toBeUndefined()
-      }
-    }
-  )
-
-  it.each`
-    length | fromUnit     | toUnit       | expectedError
-    ${10}  | ${'km'}      | ${'invalid'} | ${'Invalid units'}
-    ${5}   | ${'invalid'} | ${'m'}       | ${'Invalid units'}
-  `(
-    'returns error message for invalid units: $fromUnit to $toUnit',
-    ({ length, fromUnit, toUnit, expectedError }) => {
-      try {
-        lengthConversion(length, fromUnit, toUnit)
-      } catch (error) {
-        expect(error.message).toBe(expectedError)
-      }
-    }
-  )
+import { metresToFeet, feetToMetres } from '../LengthConversion.js'
+
+describe('metresToFeet', () => {
+  test('metresToFeet(0) returns 0', () => {
+    expect(metresToFeet(0)).toBe(0)
+  })
+
+  test('metresToFeet(1) returns 3.28084', () => {
+    expect(metresToFeet(1)).toBeCloseTo(3.28084)
+  })
+
+  test('metresToFeet(10) returns 32.8084', () => {
+    expect(metresToFeet(10)).toBeCloseTo(32.8084)
+  })
+
+  test('metresToFeet(100) returns 328.084', () => {
+    expect(metresToFeet(100)).toBeCloseTo(328.084)
+  })
+
+  test('throws TypeError for non-number input', () => {
+    expect(() => metresToFeet('10')).toThrow(TypeError)
+  })
+
+  test('throws TypeError for NaN', () => {
+    expect(() => metresToFeet(NaN)).toThrow(TypeError)
+  })
+})
+
+describe('feetToMetres', () => {
+  test('feetToMetres(0) returns 0', () => {
+    expect(feetToMetres(0)).toBe(0)
+  })
+
+  test('feetToMetres(1) returns 0.3048', () => {
+    expect(feetToMetres(1)).toBeCloseTo(0.3048)
+  })
+
+  test('feetToMetres(10) returns 3.048', () => {
+    expect(feetToMetres(10)).toBeCloseTo(3.048)
+  })
+
+  test('feetToMetres(100) returns 30.48', () => {
+    expect(feetToMetres(100)).toBeCloseTo(30.48)
+  })
+
+  test('throws TypeError for non-number input', () => {
+    expect(() => feetToMetres('10')).toThrow(TypeError)
+  })
+
+  test('throws TypeError for NaN', () => {
+    expect(() => feetToMetres(NaN)).toThrow(TypeError)
+  })
 })