Feet-and-inches entry: type 2' 7\" instead of 2.6 (#59) (#62)

Co-authored-by: Steve Dudenhoeffer <[email protected]>

web/src/lib/units.ts

@@ -40,11 +40,6 @@ export function cmFromMeters(meters: number): number {
   return roundCm(meters * CM_PER_METER)
 }
 
-/** A value typed in the given unit (meters, or feet) → centimeters. */
-export function cmFromDisplay(value: number, unit: UnitPref): number {
-  return unit === 'imperial' ? cmFromFtIn(value) : cmFromMeters(value)
-}
-
 /** Centimeters → a number in the given unit, for prefilling an input field.
  *  Rounded so cm-quantization doesn't show through (e.g. 244cm shows as 8 ft,
  *  not 8.01): meters to the cm (2 dp), feet to 0.1 ft. */
@@ -56,17 +51,116 @@ export function displayFromCm(cm: number, unit: UnitPref): number {
   return Math.round((cm / CM_PER_METER) * 100) / 100
 }
 
+// --- Dimension entry -------------------------------------------------------
+// Imperial dimensions are typed the way people say them — 2' 7", not 2.6 — while
+// a bare number still means feet so nothing anyone typed before this existed
+// breaks. Metric entry is decimal meters, unchanged.
+
+// Feet, then optionally inches. The inch mark is optional once feet are explicit,
+// because "2' 7" is a natural thing to type and unambiguous.
+const FT_IN_RE = /^(\d*\.?\d+)\s*(?:'|ft|feet|foot)(?:\s*(\d*\.?\d+)\s*(?:"|in|inch|inches)?)?$/
+// Inches alone, where the mark is required — a bare number means feet.
+const IN_ONLY_RE = /^(\d*\.?\d+)\s*(?:"|in|inch|inches)$/
+// A bare decimal, which means feet (imperial) or meters (metric).
+const BARE_RE = /^(\d*\.?\d+)$/
+const METERS_RE = /^(\d*\.?\d+)\s*m?$/
+
+/** Normalize the characters people actually paste: typographic quotes and the
+ *  various unicode dashes, so text copied from anywhere parses like text typed
+ *  here. Lowercased so "FT"/"In" work too. */
+function normalizeEntry(s: string): string {
+  return s
+    .trim()
+    .replace(/[′’‵]/g, "'")
+    .replace(/[″”‶]/g, '"')
+    .replace(/[−–—]/g, '-')
+    .toLowerCase()
+}
+
+/** Split a leading sign off a normalized entry. The sign belongs to the WHOLE
+ *  value, not just its first term: -2' 6" is −(2ft + 6in) = −30in, not −2ft + 6in. */
+function splitSign(s: string): { sign: number; rest: string } {
+  if (s.startsWith('-')) return { sign: -1, rest: s.slice(1).trim() }
+  if (s.startsWith('+')) return { sign: 1, rest: s.slice(1).trim() }
+  return { sign: 1, rest: s }
+}
+
+/**
+ * Parse a typed dimension into centimeters, or null if it isn't a dimension.
+ *
+ * Imperial accepts `2' 7"`, `2′ 7″`, `2ft 7in`, `2' 7`, `31"`, `2'`, and a bare
+ * `2.5` still meaning 2½ feet. Metric accepts decimal meters with an optional
+ * `m`. Null means "don't commit anything" — never a silent zero, which would
+ * turn a typo into a destructive edit.
+ */
+export function parseDimension(input: string, unit: UnitPref): number | null {
+  const { sign, rest } = splitSign(normalizeEntry(input))
+  if (rest === '') return null
+
+  if (unit !== 'imperial') {
+    const m = rest.match(METERS_RE)
+    return m ? sign * cmFromMeters(parseFloat(m[1])) : null
+  }
+
+  const bare = rest.match(BARE_RE)
+  if (bare) return sign * cmFromFtIn(parseFloat(bare[1]))
+
+  const ftIn = rest.match(FT_IN_RE)
+  if (ftIn) return sign * cmFromFtIn(parseFloat(ftIn[1]), ftIn[2] ? parseFloat(ftIn[2]) : 0)
+
+  const inOnly = rest.match(IN_ONLY_RE)
+  if (inOnly) return sign * cmFromFtIn(0, parseFloat(inOnly[1]))
+
+  return null
+}
+
+/**
+ * Centimeters → the string a dimension input shows, and the exact string
+ * parseDimension round-trips. Imperial reads `2′ 7″`; inches carry one decimal
+ * (`7′ 10.5″`) because 0.1″ is ~0.25 cm, so what's displayed stays honest about
+ * what's stored rather than rounding a dragged position to the nearest inch.
+ */
+export function formatDimensionInput(cm: number, unit: UnitPref): string {
+  if (unit !== 'imperial') return String(displayFromCm(cm, unit))
+  const { feet, inches } = feetAndInches(cm, 1)
+  // Only sign a value that actually rounded to something: a hair below zero is
+  // 0′ 0″, and "-0′ 0″" would be both wrong and un-round-trippable.
+  const sign = cm < 0 && (feet || inches) ? '-' : ''
+  return `${sign}${feet}′ ${inches}″`
+}
+
+/**
+ * The inputMode a dimension field should ask for. Imperial entry needs ' and ",
+ * which no numeric keypad offers, so those fields get the full keyboard; metric
+ * is pure decimals and keeps the keypad. A bare number still means feet, so the
+ * keypad path stays usable either way.
+ */
+export function dimensionInputMode(unit: UnitPref): 'text' | 'decimal' {
+  return unit === 'imperial' ? 'text' : 'decimal'
+}
+
+/**
+ * Decompose centimeters into feet and inches, rounding inches to `decimals` and
+ * carrying 12″ up to the next foot. Magnitude only — the sign is the caller's to
+ * apply, and only once it knows the rounded result isn't zero.
+ */
+function feetAndInches(cm: number, decimals: number): { feet: number; inches: number } {
+  const scale = 10 ** decimals
+  const totalInches = Math.abs(cm) / CM_PER_INCH
+  let feet = Math.floor(totalInches / INCHES_PER_FOOT)
+  let inches = Math.round((totalInches - feet * INCHES_PER_FOOT) * scale) / scale
+  if (inches >= INCHES_PER_FOOT) {
+    feet += 1
+    inches = 0
+  }
+  return { feet, inches }
+}
+
 /** Centimeters → a human string in the given unit (e.g. "1.22 m" or "4′ 0″"). */
 export function formatCm(cm: number, unit: UnitPref): string {
   if (unit === 'imperial') {
-    const totalInches = cm / CM_PER_INCH
-    let feet = Math.floor(totalInches / INCHES_PER_FOOT)
-    let inches = Math.round(totalInches - feet * INCHES_PER_FOOT)
-    if (inches === INCHES_PER_FOOT) {
-      feet += 1
-      inches = 0
-    }
-    return `${feet}′ ${inches}″`
+    const { feet, inches } = feetAndInches(cm, 0)
+    return `${cm < 0 && (feet || inches) ? '-' : ''}${feet}′ ${inches}″`
   }
   const meters = Math.round((cm / CM_PER_METER) * 100) / 100
   return `${meters} m`