@mahounou/uconv 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# UConv Node.js
+
+Lightweight unit converter for Node.js with zero runtime dependencies.
+
+## Installation
+
+```bash
+npm install
+```
+
+## Usage
+
+```javascript
+import { convert } from './src/index.js';
+
+// Distance conversions
+convert("10km", "m");      // 10000
+convert("5ft", "cm");      // 152.4
+
+// Weight conversions
+convert("5lbs", "kg");     // 2.26796
+convert("1kg", "g");       // 1000
+
+// Time conversions
+convert("1hr", "min");     // 60
+convert("30min", "s");     // 1800
+
+// Currency conversions (example rates)
+convert("100USD", "EUR");  // ~85
+```
+
+## Supported Units
+
+### Distance
+- Metric: m, km, cm, mm
+- Imperial: ft, in, yd, mi
+
+### Weight
+- Metric: g, kg, mg, t
+- Imperial: lb, oz, st
+
+### Time
+- s, min, hr, day, week, month, year
+
+### Currency
+- USD, EUR, GBP, JPY, CAD, AUD, CHF, CNY
+
+## Error Handling
+
+The library throws specific errors for different failure cases:
+
+- `UnknownUnitError`: When a unit is not recognized
+- `InvalidInputError`: When input format is invalid
+- `IncompatibleUnitsError`: When trying to convert between different unit types
+
+## Testing
+
+```bash
+npm test
+```
+
+## Base Units
+
+- Distance: meter (m)
+- Weight: gram (g)  
+- Time: second (s)
+- Currency: USD

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@mahounou/uconv",
+  "version": "0.1.0",
+  "description": "Lightweight unit converter library",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest",
+    "test:watch": "vitest --watch"
+  },
+  "keywords": ["units", "converter", "measurement", "distance", "weight", "time", "currency"],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ksnjkdppdojdim-star/Uconv"
+  },
+  "devDependencies": {
+    "vitest": "latest"
+  }
+}

package/src/converters/currency.js

@@ -0,0 +1,36 @@
+import { getConversionFactor } from '../units.js';
+import { getConversionFactor } from '../units.js';
+import { factorConvert } from '../utils/convert.js';
+
+
+/**
+ * Convert currency units
+ * Note: In production, exchange rates should be fetched from a live API
+ * @param {number} value - Value to convert
+ * @param {string} fromUnit - Source currency
+ * @param {string} toUnit - Target currency
+ * @returns {number} Converted value
+ */
+
+
+export function convertCurrency(value, fromUnit, toUnit) {
+  const from = getConversionFactor(fromUnit);
+  const to   = getConversionFactor(toUnit);
+  if (from === null || to === null) throw new Error('Invalid currency unit');
+  return factorConvert(value, from, to);
+}
+
+// Async live rates — optional
+export async function convertCurrencyLive(value, fromUnit, toUnit) {
+  const res = await fetch(`https://api.exchangerate-api.com/v4/latest/USD`);
+  if (!res.ok) throw new Error('Failed to fetch live exchange rates');
+  const { rates } = await res.json();
+
+  const from = fromUnit.toUpperCase();
+  const to   = toUnit.toUpperCase();
+
+  if (!rates[from]) throw new Error(`Unknown currency: ${from}`);
+  if (!rates[to])   throw new Error(`Unknown currency: ${to}`);
+
+  return (value / rates[from]) * rates[to];
+}

package/src/converters/distance.js

@@ -0,0 +1,20 @@
+import { getConversionFactor } from '../units.js';
+import { getConversionFactor } from '../units.js';
+import { factorConvert } from '../utils/convert.js';
+
+
+/**
+ * Convert distance units
+ * @param {number} value - Value to convert
+ * @param {string} fromUnit - Source unit
+ * @param {string} toUnit - Target unit
+ * @returns {number} Converted value
+ */
+
+
+export function convertDistance(value, fromUnit, toUnit) {
+  const from = getConversionFactor(fromUnit);
+  const to   = getConversionFactor(toUnit);
+  if (from === null || to === null) throw new Error('Invalid distance unit');
+  return factorConvert(value, from, to);
+}

package/src/converters/time.js

@@ -0,0 +1,19 @@
+import { getConversionFactor } from '../units.js';
+import { getConversionFactor } from '../units.js';
+import { factorConvert } from '../utils/convert.js';
+
+/**
+ * Convert time units
+ * @param {number} value - Value to convert
+ * @param {string} fromUnit - Source unit
+ * @param {string} toUnit - Target unit
+ * @returns {number} Converted value
+ */
+
+
+export function convertTime(value, fromUnit, toUnit) {
+  const from = getConversionFactor(fromUnit);
+  const to   = getConversionFactor(toUnit);
+  if (from === null || to === null) throw new Error('Invalid time unit');
+  return factorConvert(value, from, to);
+}

package/src/converters/utils/convert.js

@@ -0,0 +1,3 @@
+export function factorConvert(value, fromFactor, toFactor) {
+  return (value * fromFactor) / toFactor;
+}

package/src/converters/weight.js

@@ -0,0 +1,20 @@
+import { getConversionFactor } from '../units.js';
+import { getConversionFactor } from '../units.js';
+import { factorConvert } from '../utils/convert.js';
+
+
+/**
+ * Convert weight units
+ * @param {number} value - Value to convert
+ * @param {string} fromUnit - Source unit
+ * @param {string} toUnit - Target unit
+ * @returns {number} Converted value
+ */
+
+
+export function convertWeight(value, fromUnit, toUnit) {
+  const from = getConversionFactor(fromUnit);
+  const to   = getConversionFactor(toUnit);
+  if (from === null || to === null) throw new Error('Invalid weight unit');
+  return factorConvert(value, from, to);
+}

package/src/index.js

@@ -0,0 +1,77 @@
+import { parseInput } from './parser.js';
+import { getUnitCategory, isValidUnit } from './units.js';
+import { convertDistance } from './converters/distance.js';
+import { convertWeight } from './converters/weight.js';
+import { convertTime } from './converters/time.js';
+import { convertCurrency } from './converters/currency.js';
+
+// Custom error classes
+export class UnknownUnitError extends Error {
+  constructor(unit) {
+    super(`Unknown unit: ${unit}`);
+    this.name = 'UnknownUnitError';
+  }
+}
+
+export class InvalidInputError extends Error {
+  constructor(input) {
+    super(`Invalid input format: ${input}`);
+    this.name = 'InvalidInputError';
+  }
+}
+
+export class IncompatibleUnitsError extends Error {
+  constructor(fromUnit, toUnit) {
+    super(`Cannot convert from ${fromUnit} to ${toUnit}: incompatible unit types`);
+    this.name = 'IncompatibleUnitsError';
+  }
+}
+
+const converters = {
+  distance: convertDistance,
+  weight: convertWeight,
+  time: convertTime,
+  currency: convertCurrency
+};
+
+/**
+ * Convert between units
+ * @param {string} from - Source value and unit (e.g., "10km")
+ * @param {string} to - Target unit (e.g., "m")
+ * @returns {number} Converted value
+ */
+export function convert(from, to) {
+  if (typeof to !== 'string' || !to.trim()) {
+    throw new InvalidInputError(to);
+  }
+
+  const toUnit = to.trim().toLowerCase();
+
+  try {
+    const parsed = parseInput(from);
+    if (!parsed) throw new InvalidInputError(from);
+
+    const { value, unit: fromUnit } = parsed;
+
+    if (!isValidUnit(fromUnit)) throw new UnknownUnitError(fromUnit);
+    if (!isValidUnit(toUnit))   throw new UnknownUnitError(toUnit);
+
+    const fromCategory = getUnitCategory(fromUnit);
+    const toCategory   = getUnitCategory(toUnit);
+
+    if (fromCategory !== toCategory) throw new IncompatibleUnitsError(fromUnit, toUnit);
+
+    const converter = converters[fromCategory];
+    if (!converter) throw new Error(`No converter for: ${fromCategory}`);
+
+    return converter(value, fromUnit, toUnit);
+
+  } catch (error) {
+    if (error instanceof UnknownUnitError ||
+        error instanceof InvalidInputError ||
+        error instanceof IncompatibleUnitsError) {
+      throw error;
+    }
+    throw new Error(`Conversion failed: ${error.message}`);
+  }
+}

package/src/parser.js

@@ -0,0 +1,25 @@
+/**
+ * Parse input string containing value and unit
+ * @param {string} input - Input string like "10km", "5.5 lbs", "100 USD"
+ * @returns {Object|null} Parsed object {value, unit} or null if invalid
+ */
+const MAX_INPUT_LENGTH = 50;
+const MAX_VALUE = 1e15;
+const PARSE_REGEX = /^(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)\s*([a-zA-Z°]+)$/i;
+
+export function parseInput(input) {
+  if (typeof input !== 'string') return null;
+
+  const clean = input.trim();
+  if (!clean || clean.length > MAX_INPUT_LENGTH) return null;
+
+  const match = clean.match(PARSE_REGEX);
+  if (!match) return null;
+
+  const value = parseFloat(match[1]);
+
+  if (!isFinite(value)) return null;
+  if (Math.abs(value) > MAX_VALUE) return null;
+
+  return { value, unit: match[2].toLowerCase() };
+}

package/src/units.js

@@ -0,0 +1,129 @@
+// Base units for each category
+export const BASE_UNITS = {
+  distance: 'm',    // meter
+  weight: 'g',      // gram
+  time: 's',        // second
+  currency: 'usd'   // US Dollar
+};
+
+// Unit definitions with conversion factors to base units
+export const UNITS = {
+  // Distance (base: meter)
+  distance: {
+    // Metric
+    'm': 1,
+    'meter': 1,
+    'metre': 1,
+    'km': 1000,
+    'kilometer': 1000,
+    'kilometre': 1000,
+    'cm': 0.01,
+    'centimeter': 0.01,
+    'centimetre': 0.01,
+    'mm': 0.001,
+    'millimeter': 0.001,
+    'millimetre': 0.001,
+    
+    // Imperial
+    'ft': 0.3048,
+    'foot': 0.3048,
+    'feet': 0.3048,
+    'in': 0.0254,
+    'inch': 0.0254,
+    'yd': 0.9144,
+    'yard': 0.9144,
+    'mi': 1609.344,
+    'mile': 1609.344
+  },
+  
+  // Weight (base: gram)
+  weight: {
+    // Metric
+    'g': 1,
+    'gram': 1,
+    'kg': 1000,
+    'kilogram': 1000,
+    'mg': 0.001,
+    'milligram': 0.001,
+    't': 1000000,
+    'ton': 1000000,
+    'tonne': 1000000,
+    
+    // Imperial
+    'lb': 453.592,
+    'lbs': 453.592,
+    'pound': 453.592,
+    'oz': 28.3495,
+    'ounce': 28.3495,
+    'st': 6350.29,
+    'stone': 6350.29
+  },
+  
+  // Time (base: second)
+  time: {
+    's': 1,
+    'sec': 1,
+    'second': 1,
+    'min': 60,
+    'minute': 60,
+    'hr': 3600,
+    'hour': 3600,
+    'day': 86400,
+    'week': 604800,
+    'month': 2629746, // Average month
+    'year': 31556952  // Average year
+  },
+  
+  // Currency (base: USD)
+  // Note: In a real implementation, these would be fetched from an API
+  currency: {
+    // ⚠️ Static rates as of 2024-01-01 — use live option for accuracy
+    // CURRENCY_RATES_DATE: '2024-01-01'
+    'usd': 1,
+    'eur': 0.85,   // Example rates
+    'gbp': 0.75,
+    'jpy': 110,
+    'cad': 1.25,
+    'aud': 1.35,
+    'chf': 0.92,
+    'cny': 6.45
+  }
+};
+
+/**
+ * Get the category of a unit
+ * @param {string} unit - Unit name
+ * @returns {string|null} Category name or null if not found
+ */
+export function getUnitCategory(unit) {
+  const normalizedUnit = unit.toLowerCase();
+  for (const [category, units] of Object.entries(UNITS)) {
+    if (Object.hasOwn(units, normalizedUnit)) {
+      return category;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if a unit is valid
+ * @param {string} unit - Unit name
+ * @returns {boolean} True if unit exists
+ */
+export function isValidUnit(unit) {
+  return getUnitCategory(unit) !== null;
+}
+
+/**
+ * Get conversion factor to base unit
+ * @param {string} unit - Unit name
+ * @returns {number|null} Conversion factor or null if not found
+ */
+export function getConversionFactor(unit) {
+  const category = getUnitCategory(unit);
+  if (!category) {
+    return null;
+  }
+  
+  return UNITS[category][unit.toLowerCase()];
+}