"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UNIT_DEFINITIONS = void 0;
exports.normalizeUnit = normalizeUnit;
exports.getUnitDefinition = getUnitDefinition;
exports.getUnitType = getUnitType;
exports.canConvert = canConvert;
exports.convertUnit = convertUnit;
exports.UNIT_DEFINITIONS = [
    { value: 'g', labelSv: 'g (gram)', type: 'weight', toBaseFactor: 1, aliases: ['gram'] },
    { value: 'hg', labelSv: 'hg (hektogram)', type: 'weight', toBaseFactor: 100, aliases: ['hektogram'] },
    { value: 'kg', labelSv: 'kg (kilogram)', type: 'weight', toBaseFactor: 1000, aliases: ['kilo', 'kilogram'] },
    { value: 'mg', labelSv: 'mg (milligram)', type: 'weight', toBaseFactor: 0.001, aliases: ['milligram'] },
    { value: 'ml', labelSv: 'ml (milliliter)', type: 'volume', toBaseFactor: 1, aliases: ['milliliter'] },
    { value: 'cl', labelSv: 'cl (centiliter)', type: 'volume', toBaseFactor: 10, aliases: ['centiliter'] },
    { value: 'dl', labelSv: 'dl (deciliter)', type: 'volume', toBaseFactor: 100, aliases: ['deciliter'] },
    { value: 'l', labelSv: 'l (liter)', type: 'volume', toBaseFactor: 1000, aliases: ['liter'] },
    { value: 'krm', labelSv: 'krm (kryddmått)', type: 'cooking', toBaseFactor: 1, aliases: ['kryddmatt', 'kryddmått'] },
    { value: 'tsk', labelSv: 'tsk (tesked)', type: 'cooking', toBaseFactor: 5, aliases: ['tesked', 'test'] },
    { value: 'msk', labelSv: 'msk (matsked)', type: 'cooking', toBaseFactor: 15, aliases: ['matsked', 'matsled'] },
    { value: 'st', labelSv: 'st (styck)', type: 'piece', toBaseFactor: 1, aliases: ['stycke', 'styck', 'stk'] },
    { value: 'port', labelSv: 'port (portioner)', type: 'piece', toBaseFactor: 1, aliases: ['portion', 'portioner'] },
    { value: 'förp', labelSv: 'förp (förpackning)', type: 'piece', toBaseFactor: 1, aliases: ['forp', 'förpackning', 'forpackning'] },
    { value: 'klyfta', labelSv: 'klyfta', type: 'piece', toBaseFactor: 1, aliases: [] },
    { value: 'efter smak', labelSv: 'efter smak', type: 'other', toBaseFactor: 1, aliases: ['eftr smak', 'efter smak'] },
];
const _unitLookup = new Map();
for (const def of exports.UNIT_DEFINITIONS) {
    _unitLookup.set(def.value.toLowerCase(), def);
    for (const alias of def.aliases) {
        _unitLookup.set(alias.toLowerCase(), def);
    }
}
function normalizeUnit(unit) {
    const key = unit.trim().toLowerCase();
    return _unitLookup.get(key)?.value ?? key;
}
function getUnitDefinition(unit) {
    const key = unit.trim().toLowerCase();
    return _unitLookup.get(key);
}
function getUnitType(unit) {
    return getUnitDefinition(unit)?.type ?? null;
}
function canConvert(fromUnit, toUnit) {
    const from = getUnitDefinition(fromUnit);
    const to = getUnitDefinition(toUnit);
    if (!from || !to)
        return false;
    if (from.type !== to.type)
        return false;
    if (from.type === 'piece' || from.type === 'other')
        return false;
    return true;
}
function convertUnit(quantity, fromUnit, toUnit) {
    if (quantity <= 0) {
        throw new Error(`Invalid quantity: ${quantity}. Quantity must be positive.`);
    }
    const normalizedFrom = normalizeUnit(fromUnit);
    const normalizedTo = normalizeUnit(toUnit);
    if (normalizedFrom === normalizedTo)
        return quantity;
    const fromDef = getUnitDefinition(normalizedFrom);
    const toDef = getUnitDefinition(normalizedTo);
    if (!fromDef)
        throw new Error(`Unknown unit: "${fromUnit}"`);
    if (!toDef)
        throw new Error(`Unknown unit: "${toUnit}"`);
    if (fromDef.type !== toDef.type) {
        throw new Error(`Cannot convert between incompatible unit types: "${fromUnit}" (${fromDef.type}) and "${toUnit}" (${toDef.type})`);
    }
    if (fromDef.type === 'piece' || fromDef.type === 'other') {
        return quantity;
    }
    return (quantity * fromDef.toBaseFactor) / toDef.toBaseFactor;
}
//# sourceMappingURL=units.js.map