@morscherlab/mld-sdk 0.6.0

package/dist/composables/useChemicalFormula.js

@@ -0,0 +1,228 @@
+const ATOMIC_WEIGHTS = {
+  H: 1.008,
+  He: 4.003,
+  Li: 6.941,
+  Be: 9.012,
+  B: 10.81,
+  C: 12.011,
+  N: 14.007,
+  O: 15.999,
+  F: 18.998,
+  Ne: 20.18,
+  Na: 22.99,
+  Mg: 24.305,
+  Al: 26.982,
+  Si: 28.086,
+  P: 30.974,
+  S: 32.065,
+  Cl: 35.453,
+  Ar: 39.948,
+  K: 39.098,
+  Ca: 40.078,
+  Mn: 54.938,
+  Fe: 55.845,
+  Co: 58.933,
+  Ni: 58.693,
+  Cu: 63.546,
+  Zn: 65.38,
+  Br: 79.904,
+  Ag: 107.868,
+  I: 126.904,
+  Au: 196.967
+};
+function parseFormulaSegment(formula) {
+  const elements = {};
+  const stack = [{}];
+  let i = 0;
+  while (i < formula.length) {
+    const ch = formula[i];
+    if (ch === "(") {
+      stack.push({});
+      i++;
+    } else if (ch === ")") {
+      if (stack.length < 2) {
+        return { elements: {}, valid: false, error: "Unmatched closing parenthesis" };
+      }
+      i++;
+      let numStr = "";
+      while (i < formula.length && /\d/.test(formula[i])) {
+        numStr += formula[i];
+        i++;
+      }
+      const multiplier = numStr ? parseInt(numStr, 10) : 1;
+      const top = stack.pop();
+      const current = stack[stack.length - 1];
+      for (const [el, count] of Object.entries(top)) {
+        current[el] = (current[el] || 0) + count * multiplier;
+      }
+    } else if (/[A-Z]/.test(ch)) {
+      let symbol = ch;
+      i++;
+      while (i < formula.length && /[a-z]/.test(formula[i])) {
+        symbol += formula[i];
+        i++;
+      }
+      if (!(symbol in ATOMIC_WEIGHTS)) {
+        return { elements: {}, valid: false, error: `Unknown element: ${symbol}` };
+      }
+      let numStr = "";
+      while (i < formula.length && /\d/.test(formula[i])) {
+        numStr += formula[i];
+        i++;
+      }
+      const count = numStr ? parseInt(numStr, 10) : 1;
+      const current = stack[stack.length - 1];
+      current[symbol] = (current[symbol] || 0) + count;
+    } else {
+      return { elements: {}, valid: false, error: `Unexpected character: ${ch}` };
+    }
+  }
+  if (stack.length !== 1) {
+    return { elements: {}, valid: false, error: "Unmatched opening parenthesis" };
+  }
+  Object.assign(elements, stack[0]);
+  return { elements, valid: true };
+}
+function useChemicalFormula() {
+  function parseFormula(formula) {
+    const trimmed = formula.trim();
+    if (!trimmed) {
+      return { elements: {}, valid: false, error: "Empty formula" };
+    }
+    const parts = trimmed.split(/[·.]/);
+    const combined = {};
+    for (const part of parts) {
+      const segment = part.trim();
+      if (!segment) continue;
+      let coefficient = 1;
+      let formulaStr = segment;
+      const coeffMatch = segment.match(/^(\d+)([A-Z].*)$/);
+      if (coeffMatch) {
+        coefficient = parseInt(coeffMatch[1], 10);
+        formulaStr = coeffMatch[2];
+      }
+      const result = parseFormulaSegment(formulaStr);
+      if (!result.valid) {
+        return result;
+      }
+      for (const [el, count] of Object.entries(result.elements)) {
+        combined[el] = (combined[el] || 0) + count * coefficient;
+      }
+    }
+    return { elements: combined, valid: true };
+  }
+  function calculateMW(elements) {
+    let mw = 0;
+    for (const [el, count] of Object.entries(elements)) {
+      const weight = ATOMIC_WEIGHTS[el];
+      if (weight !== void 0) {
+        mw += weight * count;
+      }
+    }
+    return Math.round(mw * 1e3) / 1e3;
+  }
+  function renderFormulaParts(formula) {
+    const parts = [];
+    const trimmed = formula.trim();
+    let i = 0;
+    while (i < trimmed.length) {
+      const ch = trimmed[i];
+      if (ch === "·" || ch === "." && i > 0 && /\d/.test(trimmed[i - 1]) && i + 1 < trimmed.length && /\d/.test(trimmed[i + 1])) {
+        if (ch === "·") {
+          parts.push({ type: "dot", text: "·" });
+          i++;
+          continue;
+        }
+      }
+      if (ch === "(" || ch === ")") {
+        parts.push({ type: "paren", text: ch });
+        i++;
+        if (ch === ")" && i < trimmed.length && /\d/.test(trimmed[i])) {
+          let numStr = "";
+          while (i < trimmed.length && /\d/.test(trimmed[i])) {
+            numStr += trimmed[i];
+            i++;
+          }
+          parts.push({ type: "subscript", text: numStr });
+        }
+        continue;
+      }
+      if (ch === "^") {
+        i++;
+        let chargeStr = "";
+        while (i < trimmed.length && /[\d+\-]/.test(trimmed[i])) {
+          chargeStr += trimmed[i];
+          i++;
+        }
+        if (chargeStr) {
+          parts.push({ type: "charge", text: chargeStr });
+        }
+        continue;
+      }
+      if (/[A-Z]/.test(ch)) {
+        let symbol = ch;
+        i++;
+        while (i < trimmed.length && /[a-z]/.test(trimmed[i])) {
+          symbol += trimmed[i];
+          i++;
+        }
+        parts.push({ type: "element", text: symbol });
+        if (i < trimmed.length && /\d/.test(trimmed[i])) {
+          let numStr = "";
+          while (i < trimmed.length && /\d/.test(trimmed[i])) {
+            numStr += trimmed[i];
+            i++;
+          }
+          parts.push({ type: "subscript", text: numStr });
+          if (i < trimmed.length && (trimmed[i] === "+" || trimmed[i] === "-")) {
+            parts.push({ type: "charge", text: numStr + trimmed[i] });
+            parts.splice(parts.length - 2, 1);
+            i++;
+            continue;
+          }
+        }
+        continue;
+      }
+      if (/\d/.test(ch)) {
+        let numStr = "";
+        while (i < trimmed.length && /\d/.test(trimmed[i])) {
+          numStr += trimmed[i];
+          i++;
+        }
+        if (i < trimmed.length && (trimmed[i] === "+" || trimmed[i] === "-")) {
+          parts.push({ type: "charge", text: numStr + trimmed[i] });
+          i++;
+        } else {
+          parts.push({ type: "subscript", text: numStr });
+        }
+        continue;
+      }
+      if (ch === "+" || ch === "-") {
+        parts.push({ type: "charge", text: ch });
+        i++;
+        continue;
+      }
+      if (ch === ".") {
+        parts.push({ type: "dot", text: "·" });
+        i++;
+        continue;
+      }
+      if (/\s/.test(ch)) {
+        i++;
+        continue;
+      }
+      i++;
+    }
+    return parts;
+  }
+  return {
+    parseFormula,
+    calculateMW,
+    renderFormulaParts
+  };
+}
+export {
+  ATOMIC_WEIGHTS,
+  useChemicalFormula
+};
+//# sourceMappingURL=useChemicalFormula.js.map

package/dist/composables/useChemicalFormula.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChemicalFormula.js","sources":["../../src/composables/useChemicalFormula.ts"],"sourcesContent":["// Types\nexport interface ParsedElement {\n  symbol: string\n  count: number\n}\n\nexport interface FormulaParseResult {\n  elements: Record<string, number>\n  valid: boolean\n  error?: string\n}\n\nexport type FormulaPartType = 'element' | 'subscript' | 'superscript' | 'paren' | 'dot' | 'charge'\n\nexport interface FormulaPart {\n  type: FormulaPartType\n  text: string\n}\n\n// ~30 common elements with atomic weights\nexport const ATOMIC_WEIGHTS: Record<string, number> = {\n  H: 1.008, He: 4.003, Li: 6.941, Be: 9.012, B: 10.81,\n  C: 12.011, N: 14.007, O: 15.999, F: 18.998, Ne: 20.180,\n  Na: 22.990, Mg: 24.305, Al: 26.982, Si: 28.086, P: 30.974,\n  S: 32.065, Cl: 35.453, Ar: 39.948, K: 39.098, Ca: 40.078,\n  Mn: 54.938, Fe: 55.845, Co: 58.933, Ni: 58.693, Cu: 63.546,\n  Zn: 65.38, Br: 79.904, Ag: 107.868, I: 126.904, Au: 196.967,\n}\n\nfunction parseFormulaSegment(formula: string): FormulaParseResult {\n  const elements: Record<string, number> = {}\n  const stack: Record<string, number>[] = [{}]\n  let i = 0\n\n  while (i < formula.length) {\n    const ch = formula[i]\n\n    if (ch === '(') {\n      stack.push({})\n      i++\n    } else if (ch === ')') {\n      if (stack.length < 2) {\n        return { elements: {}, valid: false, error: 'Unmatched closing parenthesis' }\n      }\n      i++\n      // Read multiplier after closing paren\n      let numStr = ''\n      while (i < formula.length && /\\d/.test(formula[i])) {\n        numStr += formula[i]\n        i++\n      }\n      const multiplier = numStr ? parseInt(numStr, 10) : 1\n      const top = stack.pop()!\n      const current = stack[stack.length - 1]\n      for (const [el, count] of Object.entries(top)) {\n        current[el] = (current[el] || 0) + count * multiplier\n      }\n    } else if (/[A-Z]/.test(ch)) {\n      // Element symbol: uppercase letter optionally followed by lowercase\n      let symbol = ch\n      i++\n      while (i < formula.length && /[a-z]/.test(formula[i])) {\n        symbol += formula[i]\n        i++\n      }\n      // Validate element\n      if (!(symbol in ATOMIC_WEIGHTS)) {\n        return { elements: {}, valid: false, error: `Unknown element: ${symbol}` }\n      }\n      // Read count\n      let numStr = ''\n      while (i < formula.length && /\\d/.test(formula[i])) {\n        numStr += formula[i]\n        i++\n      }\n      const count = numStr ? parseInt(numStr, 10) : 1\n      const current = stack[stack.length - 1]\n      current[symbol] = (current[symbol] || 0) + count\n    } else {\n      return { elements: {}, valid: false, error: `Unexpected character: ${ch}` }\n    }\n  }\n\n  if (stack.length !== 1) {\n    return { elements: {}, valid: false, error: 'Unmatched opening parenthesis' }\n  }\n\n  Object.assign(elements, stack[0])\n  return { elements, valid: true }\n}\n\nexport function useChemicalFormula() {\n  function parseFormula(formula: string): FormulaParseResult {\n    const trimmed = formula.trim()\n    if (!trimmed) {\n      return { elements: {}, valid: false, error: 'Empty formula' }\n    }\n\n    // Split on hydrate separator (· or .)\n    const parts = trimmed.split(/[·.]/)\n    const combined: Record<string, number> = {}\n\n    for (const part of parts) {\n      const segment = part.trim()\n      if (!segment) continue\n\n      // Check for leading coefficient (e.g., 5H2O)\n      let coefficient = 1\n      let formulaStr = segment\n      const coeffMatch = segment.match(/^(\\d+)([A-Z].*)$/)\n      if (coeffMatch) {\n        coefficient = parseInt(coeffMatch[1], 10)\n        formulaStr = coeffMatch[2]\n      }\n\n      const result = parseFormulaSegment(formulaStr)\n      if (!result.valid) {\n        return result\n      }\n\n      for (const [el, count] of Object.entries(result.elements)) {\n        combined[el] = (combined[el] || 0) + count * coefficient\n      }\n    }\n\n    return { elements: combined, valid: true }\n  }\n\n  function calculateMW(elements: Record<string, number>): number {\n    let mw = 0\n    for (const [el, count] of Object.entries(elements)) {\n      const weight = ATOMIC_WEIGHTS[el]\n      if (weight !== undefined) {\n        mw += weight * count\n      }\n    }\n    return Math.round(mw * 1000) / 1000\n  }\n\n  function renderFormulaParts(formula: string): FormulaPart[] {\n    const parts: FormulaPart[] = []\n    const trimmed = formula.trim()\n    let i = 0\n\n    while (i < trimmed.length) {\n      const ch = trimmed[i]\n\n      // Hydrate dot separator\n      if (ch === '·' || (ch === '.' && i > 0 && /\\d/.test(trimmed[i - 1]) && i + 1 < trimmed.length && /\\d/.test(trimmed[i + 1]))) {\n        // Disambiguate: '.' as hydrate separator only if followed by a digit then uppercase\n        // For simplicity, treat '·' always as dot\n        if (ch === '·') {\n          parts.push({ type: 'dot', text: '·' })\n          i++\n          continue\n        }\n      }\n\n      // Parentheses\n      if (ch === '(' || ch === ')') {\n        parts.push({ type: 'paren', text: ch })\n        i++\n        // After ')' check for subscript number\n        if (ch === ')' && i < trimmed.length && /\\d/.test(trimmed[i])) {\n          let numStr = ''\n          while (i < trimmed.length && /\\d/.test(trimmed[i])) {\n            numStr += trimmed[i]\n            i++\n          }\n          parts.push({ type: 'subscript', text: numStr })\n        }\n        continue\n      }\n\n      // Charge notation: ^2+, ^2-, 2+, 2- at end, or +, -\n      if (ch === '^') {\n        i++\n        let chargeStr = ''\n        while (i < trimmed.length && /[\\d+\\-]/.test(trimmed[i])) {\n          chargeStr += trimmed[i]\n          i++\n        }\n        if (chargeStr) {\n          parts.push({ type: 'charge', text: chargeStr })\n        }\n        continue\n      }\n\n      // Element symbol: uppercase followed by optional lowercase\n      if (/[A-Z]/.test(ch)) {\n        let symbol = ch\n        i++\n        while (i < trimmed.length && /[a-z]/.test(trimmed[i])) {\n          symbol += trimmed[i]\n          i++\n        }\n        parts.push({ type: 'element', text: symbol })\n\n        // Check for subscript number after element\n        if (i < trimmed.length && /\\d/.test(trimmed[i])) {\n          let numStr = ''\n          while (i < trimmed.length && /\\d/.test(trimmed[i])) {\n            numStr += trimmed[i]\n            i++\n          }\n          parts.push({ type: 'subscript', text: numStr })\n\n          // Check for charge after subscript (e.g., Fe2+ or SO4^2-)\n          if (i < trimmed.length && (trimmed[i] === '+' || trimmed[i] === '-')) {\n            parts.push({ type: 'charge', text: numStr + trimmed[i] })\n            // Remove the subscript we just added since it's actually part of charge\n            // Actually, for cases like Fe2+, the 2+ is the charge, not a subscript\n            // But for H2O the 2 is a subscript. We need context.\n            // Simplification: if followed by +/-, treat trailing digits as part of charge\n            parts.splice(parts.length - 2, 1) // Remove the subscript\n            i++\n            continue\n          }\n        }\n        continue\n      }\n\n      // Leading digit (hydrate coefficient like 5H2O)\n      if (/\\d/.test(ch)) {\n        let numStr = ''\n        while (i < trimmed.length && /\\d/.test(trimmed[i])) {\n          numStr += trimmed[i]\n          i++\n        }\n        // Could be a subscript or coefficient depending on context\n        // If next char is uppercase, it's a coefficient (render as element-like text)\n        // If at end or followed by +/-, it's a charge component\n        if (i < trimmed.length && (trimmed[i] === '+' || trimmed[i] === '-')) {\n          parts.push({ type: 'charge', text: numStr + trimmed[i] })\n          i++\n        } else {\n          parts.push({ type: 'subscript', text: numStr })\n        }\n        continue\n      }\n\n      // Standalone + or - (charge)\n      if (ch === '+' || ch === '-') {\n        parts.push({ type: 'charge', text: ch })\n        i++\n        continue\n      }\n\n      // Dot as hydrate separator\n      if (ch === '.') {\n        parts.push({ type: 'dot', text: '·' })\n        i++\n        continue\n      }\n\n      // Skip whitespace\n      if (/\\s/.test(ch)) {\n        i++\n        continue\n      }\n\n      // Unknown character, skip\n      i++\n    }\n\n    return parts\n  }\n\n  return {\n    parseFormula,\n    calculateMW,\n    renderFormulaParts,\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/composables/useConcentrationUnits.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef } from 'vue';
+export type MolarityUnit = 'pM' | 'nM' | 'µM' | 'mM' | 'M';
+export type MassVolumeUnit = 'pg/mL' | 'ng/mL' | 'µg/mL' | 'mg/mL' | 'g/mL';
+export type PercentageUnit = '% v/v' | '% w/v' | '% w/w';
+export type ConcentrationUnit = MolarityUnit | MassVolumeUnit | PercentageUnit | string;
+export interface ConcentrationValue {
+    value: number;
+    unit: ConcentrationUnit;
+}
+export interface UnitCategory {
+    label: string;
+    units: ConcentrationUnit[];
+}
+export interface UseConcentrationUnitsReturn {
+    unitCategories: ComputedRef<UnitCategory[]>;
+    molarityUnits: MolarityUnit[];
+    massVolumeUnits: MassVolumeUnit[];
+    percentageUnits: PercentageUnit[];
+    convert: (value: number, from: ConcentrationUnit, to: ConcentrationUnit, mw?: number) => number | null;
+    formatWithUnit: (concentration: ConcentrationValue, precision?: number) => string;
+    parseConcentration: (input: string) => ConcentrationValue | null;
+    getBaseUnit: (unit: ConcentrationUnit) => ConcentrationUnit;
+    getConversionHint: (concentration: ConcentrationValue) => string | null;
+    isMolarity: (unit: ConcentrationUnit) => boolean;
+    isMassVolume: (unit: ConcentrationUnit) => boolean;
+    isPercentage: (unit: ConcentrationUnit) => boolean;
+}
+export declare function useConcentrationUnits(): UseConcentrationUnitsReturn;

package/dist/composables/useConcentrationUnits.js

@@ -0,0 +1,154 @@
+import { computed } from "vue";
+const MOLARITY_FACTORS = {
+  "pM": 1e-12,
+  "nM": 1e-9,
+  "µM": 1e-6,
+  "mM": 1e-3,
+  "M": 1
+};
+const MASS_VOLUME_FACTORS = {
+  "pg/mL": 1e-12,
+  "ng/mL": 1e-9,
+  "µg/mL": 1e-6,
+  "mg/mL": 1e-3,
+  "g/mL": 1
+};
+const MOLARITY_UNITS = ["pM", "nM", "µM", "mM", "M"];
+const MASS_VOLUME_UNITS = ["pg/mL", "ng/mL", "µg/mL", "mg/mL", "g/mL"];
+const PERCENTAGE_UNITS = ["% v/v", "% w/v", "% w/w"];
+function useConcentrationUnits() {
+  const unitCategories = computed(() => [
+    { label: "Molarity", units: MOLARITY_UNITS },
+    { label: "Mass/Volume", units: MASS_VOLUME_UNITS },
+    { label: "Percentage", units: PERCENTAGE_UNITS }
+  ]);
+  function isMolarity(unit) {
+    return MOLARITY_UNITS.includes(unit);
+  }
+  function isMassVolume(unit) {
+    return MASS_VOLUME_UNITS.includes(unit);
+  }
+  function isPercentage(unit) {
+    return PERCENTAGE_UNITS.includes(unit);
+  }
+  function getBaseUnit(unit) {
+    if (isMolarity(unit)) return "M";
+    if (isMassVolume(unit)) return "g/mL";
+    if (isPercentage(unit)) return "% w/v";
+    return unit;
+  }
+  function convert(value, from, to, mw) {
+    if (from === to) return value;
+    if (value === 0) return 0;
+    if (isMolarity(from) && isMolarity(to)) {
+      const baseValue = value * MOLARITY_FACTORS[from];
+      return baseValue / MOLARITY_FACTORS[to];
+    }
+    if (isMassVolume(from) && isMassVolume(to)) {
+      const baseValue = value * MASS_VOLUME_FACTORS[from];
+      return baseValue / MASS_VOLUME_FACTORS[to];
+    }
+    if (isPercentage(from) && isPercentage(to)) {
+      return value;
+    }
+    if (mw && mw > 0) {
+      if (isMolarity(from) && isMassVolume(to)) {
+        const molarConc = value * MOLARITY_FACTORS[from];
+        const massConc = molarConc * mw;
+        return massConc / MASS_VOLUME_FACTORS[to];
+      }
+      if (isMassVolume(from) && isMolarity(to)) {
+        const massConc = value * MASS_VOLUME_FACTORS[from];
+        const molarConc = massConc / mw;
+        return molarConc / MOLARITY_FACTORS[to];
+      }
+    }
+    return null;
+  }
+  function formatWithUnit(concentration, precision = 3) {
+    const { value, unit } = concentration;
+    if (value === 0) return `0 ${unit}`;
+    let formattedValue;
+    if (Math.abs(value) >= 1e3) {
+      formattedValue = value.toExponential(precision - 1);
+    } else if (Math.abs(value) < 1e-3) {
+      formattedValue = value.toExponential(precision - 1);
+    } else {
+      formattedValue = value.toPrecision(precision);
+    }
+    formattedValue = formattedValue.replace(/\.?0+$/, "");
+    formattedValue = formattedValue.replace(/\.?0+e/, "e");
+    return `${formattedValue} ${unit}`;
+  }
+  function parseConcentration(input) {
+    const trimmed = input.trim();
+    if (!trimmed) return null;
+    const match = trimmed.match(/^([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)\s*(.*)$/);
+    if (!match) return null;
+    const value = parseFloat(match[1]);
+    if (isNaN(value)) return null;
+    let unit = match[2].trim();
+    if (!unit) {
+      return null;
+    }
+    unit = unit.replace(/uM/i, "µM").replace(/um/i, "µM").replace(/ug\/ml/i, "µg/mL").replace(/ng\/ml/i, "ng/mL").replace(/mg\/ml/i, "mg/mL").replace(/pg\/ml/i, "pg/mL").replace(/g\/ml/i, "g/mL");
+    return { value, unit };
+  }
+  function getConversionHint(concentration) {
+    const { value, unit } = concentration;
+    if (value === 0) return null;
+    if (isMolarity(unit)) {
+      const index = MOLARITY_UNITS.indexOf(unit);
+      if (value >= 1e3 && index < MOLARITY_UNITS.length - 1) {
+        const nextUnit = MOLARITY_UNITS[index + 1];
+        const converted = convert(value, unit, nextUnit);
+        if (converted !== null) {
+          return formatWithUnit({ value: converted, unit: nextUnit });
+        }
+      }
+      if (value < 1 && index > 0) {
+        const prevUnit = MOLARITY_UNITS[index - 1];
+        const converted = convert(value, unit, prevUnit);
+        if (converted !== null) {
+          return formatWithUnit({ value: converted, unit: prevUnit });
+        }
+      }
+    }
+    if (isMassVolume(unit)) {
+      const index = MASS_VOLUME_UNITS.indexOf(unit);
+      if (value >= 1e3 && index < MASS_VOLUME_UNITS.length - 1) {
+        const nextUnit = MASS_VOLUME_UNITS[index + 1];
+        const converted = convert(value, unit, nextUnit);
+        if (converted !== null) {
+          return formatWithUnit({ value: converted, unit: nextUnit });
+        }
+      }
+      if (value < 1 && index > 0) {
+        const prevUnit = MASS_VOLUME_UNITS[index - 1];
+        const converted = convert(value, unit, prevUnit);
+        if (converted !== null) {
+          return formatWithUnit({ value: converted, unit: prevUnit });
+        }
+      }
+    }
+    return null;
+  }
+  return {
+    unitCategories,
+    molarityUnits: MOLARITY_UNITS,
+    massVolumeUnits: MASS_VOLUME_UNITS,
+    percentageUnits: PERCENTAGE_UNITS,
+    convert,
+    formatWithUnit,
+    parseConcentration,
+    getBaseUnit,
+    getConversionHint,
+    isMolarity,
+    isMassVolume,
+    isPercentage
+  };
+}
+export {
+  useConcentrationUnits
+};
+//# sourceMappingURL=useConcentrationUnits.js.map

package/dist/composables/useConcentrationUnits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConcentrationUnits.js","sources":["../../src/composables/useConcentrationUnits.ts"],"sourcesContent":["import { computed, type ComputedRef } from 'vue'\n\n// Concentration unit types\nexport type MolarityUnit = 'pM' | 'nM' | 'µM' | 'mM' | 'M'\nexport type MassVolumeUnit = 'pg/mL' | 'ng/mL' | 'µg/mL' | 'mg/mL' | 'g/mL'\nexport type PercentageUnit = '% v/v' | '% w/v' | '% w/w'\nexport type ConcentrationUnit = MolarityUnit | MassVolumeUnit | PercentageUnit | string\n\nexport interface ConcentrationValue {\n  value: number\n  unit: ConcentrationUnit\n}\n\nexport interface UnitCategory {\n  label: string\n  units: ConcentrationUnit[]\n}\n\nexport interface UseConcentrationUnitsReturn {\n  unitCategories: ComputedRef<UnitCategory[]>\n  molarityUnits: MolarityUnit[]\n  massVolumeUnits: MassVolumeUnit[]\n  percentageUnits: PercentageUnit[]\n  convert: (value: number, from: ConcentrationUnit, to: ConcentrationUnit, mw?: number) => number | null\n  formatWithUnit: (concentration: ConcentrationValue, precision?: number) => string\n  parseConcentration: (input: string) => ConcentrationValue | null\n  getBaseUnit: (unit: ConcentrationUnit) => ConcentrationUnit\n  getConversionHint: (concentration: ConcentrationValue) => string | null\n  isMolarity: (unit: ConcentrationUnit) => boolean\n  isMassVolume: (unit: ConcentrationUnit) => boolean\n  isPercentage: (unit: ConcentrationUnit) => boolean\n}\n\n// Conversion factors to base unit (M for molarity, g/mL for mass/volume)\nconst MOLARITY_FACTORS: Record<MolarityUnit, number> = {\n  'pM': 1e-12,\n  'nM': 1e-9,\n  'µM': 1e-6,\n  'mM': 1e-3,\n  'M': 1,\n}\n\nconst MASS_VOLUME_FACTORS: Record<MassVolumeUnit, number> = {\n  'pg/mL': 1e-12,\n  'ng/mL': 1e-9,\n  'µg/mL': 1e-6,\n  'mg/mL': 1e-3,\n  'g/mL': 1,\n}\n\n// Percentage conversion factors (for potential future use)\n// const PERCENTAGE_FACTORS: Record<PercentageUnit, number> = {\n//   '% v/v': 0.01,\n//   '% w/v': 0.01,\n//   '% w/w': 0.01,\n// }\n\nconst MOLARITY_UNITS: MolarityUnit[] = ['pM', 'nM', 'µM', 'mM', 'M']\nconst MASS_VOLUME_UNITS: MassVolumeUnit[] = ['pg/mL', 'ng/mL', 'µg/mL', 'mg/mL', 'g/mL']\nconst PERCENTAGE_UNITS: PercentageUnit[] = ['% v/v', '% w/v', '% w/w']\n\nexport function useConcentrationUnits(): UseConcentrationUnitsReturn {\n  const unitCategories = computed<UnitCategory[]>(() => [\n    { label: 'Molarity', units: MOLARITY_UNITS },\n    { label: 'Mass/Volume', units: MASS_VOLUME_UNITS },\n    { label: 'Percentage', units: PERCENTAGE_UNITS },\n  ])\n\n  function isMolarity(unit: ConcentrationUnit): unit is MolarityUnit {\n    return MOLARITY_UNITS.includes(unit as MolarityUnit)\n  }\n\n  function isMassVolume(unit: ConcentrationUnit): unit is MassVolumeUnit {\n    return MASS_VOLUME_UNITS.includes(unit as MassVolumeUnit)\n  }\n\n  function isPercentage(unit: ConcentrationUnit): unit is PercentageUnit {\n    return PERCENTAGE_UNITS.includes(unit as PercentageUnit)\n  }\n\n  function getBaseUnit(unit: ConcentrationUnit): ConcentrationUnit {\n    if (isMolarity(unit)) return 'M'\n    if (isMassVolume(unit)) return 'g/mL'\n    if (isPercentage(unit)) return '% w/v'\n    return unit\n  }\n\n  function convert(\n    value: number,\n    from: ConcentrationUnit,\n    to: ConcentrationUnit,\n    mw?: number\n  ): number | null {\n    if (from === to) return value\n    if (value === 0) return 0\n\n    // Same category conversion\n    if (isMolarity(from) && isMolarity(to)) {\n      const baseValue = value * MOLARITY_FACTORS[from]\n      return baseValue / MOLARITY_FACTORS[to]\n    }\n\n    if (isMassVolume(from) && isMassVolume(to)) {\n      const baseValue = value * MASS_VOLUME_FACTORS[from]\n      return baseValue / MASS_VOLUME_FACTORS[to]\n    }\n\n    if (isPercentage(from) && isPercentage(to)) {\n      // Percentage conversions within same category are direct\n      return value\n    }\n\n    // Cross-category conversion (requires molecular weight)\n    if (mw && mw > 0) {\n      // Molarity to Mass/Volume\n      if (isMolarity(from) && isMassVolume(to)) {\n        // Convert to M, then to g/mL using MW, then to target unit\n        const molarConc = value * MOLARITY_FACTORS[from]\n        const massConc = molarConc * mw // g/mL (MW in g/mol, concentration in mol/L = g/L)\n        return massConc / MASS_VOLUME_FACTORS[to]\n      }\n\n      // Mass/Volume to Molarity\n      if (isMassVolume(from) && isMolarity(to)) {\n        // Convert to g/mL, then to M using MW, then to target unit\n        const massConc = value * MASS_VOLUME_FACTORS[from]\n        const molarConc = massConc / mw // M (g/mL / g/mol = mol/L)\n        return molarConc / MOLARITY_FACTORS[to]\n      }\n    }\n\n    return null // Cannot convert without MW or between incompatible units\n  }\n\n  function formatWithUnit(concentration: ConcentrationValue, precision: number = 3): string {\n    const { value, unit } = concentration\n    if (value === 0) return `0 ${unit}`\n\n    // Use appropriate precision based on value magnitude\n    let formattedValue: string\n    if (Math.abs(value) >= 1000) {\n      formattedValue = value.toExponential(precision - 1)\n    } else if (Math.abs(value) < 0.001) {\n      formattedValue = value.toExponential(precision - 1)\n    } else {\n      formattedValue = value.toPrecision(precision)\n    }\n\n    // Remove trailing zeros after decimal point\n    formattedValue = formattedValue.replace(/\\.?0+$/, '')\n    formattedValue = formattedValue.replace(/\\.?0+e/, 'e')\n\n    return `${formattedValue} ${unit}`\n  }\n\n  function parseConcentration(input: string): ConcentrationValue | null {\n    const trimmed = input.trim()\n    if (!trimmed) return null\n\n    // Match number followed by optional unit\n    const match = trimmed.match(/^([-+]?\\d*\\.?\\d+(?:[eE][-+]?\\d+)?)\\s*(.*)$/)\n    if (!match) return null\n\n    const value = parseFloat(match[1])\n    if (isNaN(value)) return null\n\n    let unit = match[2].trim()\n    if (!unit) {\n      return null // Unit is required\n    }\n\n    // Normalize common variations\n    unit = unit\n      .replace(/uM/i, 'µM')\n      .replace(/um/i, 'µM')\n      .replace(/ug\\/ml/i, 'µg/mL')\n      .replace(/ng\\/ml/i, 'ng/mL')\n      .replace(/mg\\/ml/i, 'mg/mL')\n      .replace(/pg\\/ml/i, 'pg/mL')\n      .replace(/g\\/ml/i, 'g/mL')\n\n    return { value, unit }\n  }\n\n  function getConversionHint(concentration: ConcentrationValue): string | null {\n    const { value, unit } = concentration\n    if (value === 0) return null\n\n    // Find adjacent unit for conversion hint\n    if (isMolarity(unit)) {\n      const index = MOLARITY_UNITS.indexOf(unit)\n      // If value is large, suggest next higher unit\n      if (value >= 1000 && index < MOLARITY_UNITS.length - 1) {\n        const nextUnit = MOLARITY_UNITS[index + 1]\n        const converted = convert(value, unit, nextUnit)\n        if (converted !== null) {\n          return formatWithUnit({ value: converted, unit: nextUnit })\n        }\n      }\n      // If value is small, suggest next lower unit\n      if (value < 1 && index > 0) {\n        const prevUnit = MOLARITY_UNITS[index - 1]\n        const converted = convert(value, unit, prevUnit)\n        if (converted !== null) {\n          return formatWithUnit({ value: converted, unit: prevUnit })\n        }\n      }\n    }\n\n    if (isMassVolume(unit)) {\n      const index = MASS_VOLUME_UNITS.indexOf(unit)\n      if (value >= 1000 && index < MASS_VOLUME_UNITS.length - 1) {\n        const nextUnit = MASS_VOLUME_UNITS[index + 1]\n        const converted = convert(value, unit, nextUnit)\n        if (converted !== null) {\n          return formatWithUnit({ value: converted, unit: nextUnit })\n        }\n      }\n      if (value < 1 && index > 0) {\n        const prevUnit = MASS_VOLUME_UNITS[index - 1]\n        const converted = convert(value, unit, prevUnit)\n        if (converted !== null) {\n          return formatWithUnit({ value: converted, unit: prevUnit })\n        }\n      }\n    }\n\n    return null\n  }\n\n  return {\n    unitCategories,\n    molarityUnits: MOLARITY_UNITS,\n    massVolumeUnits: MASS_VOLUME_UNITS,\n    percentageUnits: PERCENTAGE_UNITS,\n    convert,\n    formatWithUnit,\n    parseConcentration,\n    getBaseUnit,\n    getConversionHint,\n    isMolarity,\n    isMassVolume,\n    isPercentage,\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/composables/useDoseCalculator.d.ts

@@ -0,0 +1,57 @@
+import { ConcentrationValue, MolarityUnit, MassVolumeUnit } from './useConcentrationUnits';
+export type VolumeUnit = 'µL' | 'mL' | 'L';
+export interface VolumeValue {
+    value: number;
+    unit: VolumeUnit;
+}
+export interface DilutionParams {
+    stockConcentration: ConcentrationValue;
+    finalConcentration: ConcentrationValue;
+    finalVolume: VolumeValue;
+}
+export interface DilutionResult {
+    stockVolume: VolumeValue;
+    diluentVolume: VolumeValue;
+    dilutionFactor: number;
+    valid: boolean;
+    error?: string;
+}
+export interface SerialDilutionParams {
+    startingConcentration: ConcentrationValue;
+    dilutionFactor: number;
+    numberOfDilutions: number;
+    volumePerWell: VolumeValue;
+}
+export interface SerialDilutionStep {
+    stepNumber: number;
+    concentration: ConcentrationValue;
+    transferVolume: VolumeValue;
+    diluentVolume: VolumeValue;
+}
+export interface SerialDilutionResult {
+    steps: SerialDilutionStep[];
+    totalStockVolume: VolumeValue;
+    valid: boolean;
+    error?: string;
+}
+export interface ConversionResult {
+    result: ConcentrationValue;
+    valid: boolean;
+    error?: string;
+}
+export interface WellConcentration {
+    wellId: string;
+    concentration: ConcentrationValue;
+    volume?: VolumeValue;
+}
+export interface UseDoseCalculatorReturn {
+    volumeUnits: VolumeUnit[];
+    calculateDilution: (params: DilutionParams) => DilutionResult;
+    calculateSerialDilution: (params: SerialDilutionParams) => SerialDilutionResult;
+    convertMassToMolar: (mass: number, massUnit: MassVolumeUnit, mw: number) => ConcentrationValue;
+    convertMolarToMass: (molar: number, molarUnit: MolarityUnit, mw: number) => ConcentrationValue;
+    convertVolume: (value: number, from: VolumeUnit, to: VolumeUnit) => number;
+    formatVolume: (volume: VolumeValue, precision?: number) => string;
+    generateWellConcentrations: (result: SerialDilutionResult, wellIds: string[]) => WellConcentration[];
+}
+export declare function useDoseCalculator(): UseDoseCalculatorReturn;