format-quantity 3.0.0 → 3.1.0

package/dist/format-quantity.iife.umd.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-quantity.iife.umd.min.js","names":[],"sources":["../src/constants.ts","../src/formatQuantity.ts"],"sourcesContent":["import type {\n  ResolvedFormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Default tolerance used by {@link formatQuantity} when determining if a number\n * is close enough to a fraction value to be considered equivalent.\n */\nexport const defaultTolerance = 0.0075 as const;\n\n/**\n * Default options for {@link formatQuantity}.\n */\nexport const defaultOptions: ResolvedFormatQuantityOptions = {\n  vulgarFractions: false,\n  tolerance: defaultTolerance,\n  fractionSlash: false,\n  romanNumerals: false,\n} as const;\n\n/**\n * Map of vulgar fractions to their traditional ASCII equivalents.\n */\nexport const vulgarToAsciiMap: Record<VulgarFraction, SimpleFraction> = {\n  '¼': '1/4',\n  '½': '1/2',\n  '¾': '3/4',\n  '⅐': '1/7',\n  '⅑': '1/9',\n  '⅒': '1/10',\n  '⅓': '1/3',\n  '⅔': '2/3',\n  '⅕': '1/5',\n  '⅖': '2/5',\n  '⅗': '3/5',\n  '⅘': '4/5',\n  '⅙': '1/6',\n  '⅚': '5/6',\n  '⅛': '1/8',\n  '⅜': '3/8',\n  '⅝': '5/8',\n  '⅞': '7/8',\n} as const;\n\n/**\n * Map of \"close enough\" decimal values to the {@link VulgarFraction} or\n * {@link Sixteenth} fraction string matches.\n */\nexport const fractionDecimalMatches: [number, VulgarFraction | Sixteenth][] = [\n  [0.33, '⅓'],\n  [0.66, '⅔'],\n  [0.2, '⅕'],\n  [0.4, '⅖'],\n  [0.6, '⅗'],\n  [0.8, '⅘'],\n  [0.166, '⅙'],\n  [0.833, '⅚'],\n  [0.143, '⅐'],\n  [0.111, '⅑'],\n  [0.1, '⅒'],\n  [0.125, '⅛'],\n  [0.25, '¼'],\n  [0.375, '⅜'],\n  [0.5, '½'],\n  [0.625, '⅝'],\n  [0.75, '¾'],\n  [0.875, '⅞'],\n  [0.0625, '1/16'],\n  [0.1875, '3/16'],\n  [0.3125, '5/16'],\n  [0.4375, '7/16'],\n  [0.5625, '9/16'],\n  [0.6875, '11/16'],\n  [0.8125, '13/16'],\n  [0.9375, '15/16'],\n] as const;\n","import { numericQuantity } from 'numeric-quantity';\nimport {\n  defaultOptions,\n  fractionDecimalMatches,\n  vulgarToAsciiMap,\n} from './constants';\nimport type {\n  FormatQuantity,\n  FormatQuantityOptions,\n  ResolvedFormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Determines if two numbers are close enough to consider\n * them equal for the purposes of this package.\n */\nconst closeEnough = (n1: number, n2: number, tolerance: number) =>\n  Math.abs(n1 - n2) < tolerance;\n\nconst superscriptDigits = '⁰¹²³⁴⁵⁶⁷⁸⁹';\nconst subscriptDigits = '₀₁₂₃₄₅₆₇₈₉';\n\nconst toSuperscript = (s: string) => {\n  let r = '';\n  for (let i = 0; i < s.length; i++) r += superscriptDigits[+s[i]];\n  return r;\n};\nconst toSubscript = (s: string) => {\n  let r = '';\n  for (let i = 0; i < s.length; i++) r += subscriptDigits[+s[i]];\n  return r;\n};\n\n/**\n * Applies the `vulgarFractions` or `fractionSlash` options as necessary.\n */\nconst getFraction = (\n  vulgarFractionOrSixteenth: VulgarFraction | Sixteenth,\n  { fractionSlash, vulgarFractions }: FormatQuantityOptions\n) => {\n  if (vulgarFractions) {\n    return vulgarFractionOrSixteenth;\n  }\n\n  const plainFraction: SimpleFraction =\n    vulgarToAsciiMap[vulgarFractionOrSixteenth as VulgarFraction] ??\n    vulgarFractionOrSixteenth;\n\n  if (fractionSlash) {\n    const [num, den] = plainFraction.split('/');\n    return `${toSuperscript(num)}⁄${toSubscript(den)}`;\n  }\n\n  return plainFraction;\n};\n\n/**\n * Merges options object with default options, converting boolean to object if necessary.\n */\nconst normalizeOptions = (\n  options: Parameters<FormatQuantity>[1]\n): ResolvedFormatQuantityOptions => ({\n  ...defaultOptions,\n  ...(typeof options === 'boolean' ? { vulgarFractions: options } : options),\n});\n\n// prettier-ignore\nconst romanNumeralValueKey = [\n  \"\", \"C\", \"CC\", \"CCC\", \"CD\", \"D\", \"DC\", \"DCC\", \"DCCC\", \"CM\",\n  \"\", \"X\", \"XX\", \"XXX\", \"XL\", \"L\", \"LX\", \"LXX\", \"LXXX\", \"XC\",\n  \"\", \"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\", \"VIII\", \"IX\",\n] as const;\n\n/**\n * Formats a number as Roman numerals. The number must be between\n * 1 and 3999, inclusive.\n */\nexport const formatRomanNumerals = (qty: number): string | null => {\n  if (typeof qty !== 'number' || isNaN(qty)) {\n    return null;\n  }\n\n  if (qty < 1 || qty >= 4000) {\n    return '';\n  }\n\n  const floored = Math.floor(qty);\n\n  const digits = `${floored}`.split('');\n  let roman = '';\n  let i = 3;\n  while (i--) {\n    roman = `${romanNumeralValueKey[+digits.pop()! + i * 10] || ''}${roman}`;\n  }\n\n  return `${Array(+digits.join('') + 1).join('M')}${roman}`;\n};\n\n/**\n * Formats a number (or string that appears to be a number)\n * as one would see it written in imperial measurements, e.g.\n * \"1 1/2\" instead of \"1.5\". To use vulgar fraction characters\n * like \"½\", pass `true` as the second argument. For other options\n * see {@link FormatQuantityOptions}.\n */\nexport const formatQuantity: FormatQuantity = (\n  qty,\n  options = defaultOptions\n) => {\n  const qtyAsNumber =\n    typeof qty === 'string'\n      ? numericQuantity(qty, { round: false, allowTrailingInvalid: true })\n      : qty;\n\n  // Return `null` if input is not number-like.\n  if (isNaN(qtyAsNumber) || qtyAsNumber === null) {\n    return null;\n  }\n\n  // Return an empty string if the value is zero.\n  // TODO: Consider a `zeroDisplay` option (e.g. `{ zeroDisplay: \"0\" }`) so\n  // callers outside the recipe-ingredient use case can get \"0\" instead of \"\".\n  if (qtyAsNumber === 0) {\n    return '';\n  }\n\n  // The default options parameter in the function signature only takes effect\n  // if the parameter is `undefined`. The nullish coalescing operator below\n  // covers the `null` case.\n  const opts = normalizeOptions(options ?? defaultOptions);\n\n  if (opts.romanNumerals) {\n    return formatRomanNumerals(qtyAsNumber);\n  }\n\n  const absoluteValue = Math.abs(qtyAsNumber);\n  const flooredAbsVal = Math.floor(absoluteValue);\n  const sign = qtyAsNumber < 0 ? '-' : '';\n  const wholeStr = flooredAbsVal === 0 ? '' : `${flooredAbsVal}`;\n  const decimalValue = absoluteValue - flooredAbsVal;\n\n  // For integers just return the given value as a string.\n  if (decimalValue === 0) {\n    return `${qtyAsNumber}`;\n  }\n\n  for (const [num, vf] of fractionDecimalMatches) {\n    if (closeEnough(decimalValue, num, opts.tolerance)) {\n      const fraction = getFraction(vf, opts);\n      const isVulgar = fraction in vulgarToAsciiMap;\n      const sep = wholeStr\n        ? (opts.separator ?? (isVulgar ? '' : ' '))\n        : '';\n      return `${sign}${wholeStr}${sep}${fraction}`;\n    }\n  }\n\n  return `${qtyAsNumber}`;\n};\n"],"mappings":"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"}

package/dist/format-quantity.legacy-esm.d.ts

@@ -0,0 +1,107 @@
+//#region src/types.d.ts
+interface FormatQuantityOptions {
+  /**
+  * Output vulgar fractions, like "½" instead of "1/2", when appropriate.
+  * Overrides the `fractionSlash` option.
+  */
+  vulgarFractions?: boolean;
+  /**
+  * Amount by which a number can deviate from the calculated quotient to be
+  * considered a match. For example, 0.66 is close enough to 2 ÷ 3 (which
+  * is 0.66666... repeating) to be considered equivalent so the function
+  * will return "2/3". The smaller this number, the higher the likelihood that
+  * the function will return a decimal instead of a fraction or mixed number.
+  *
+  * @default 0.0075
+  */
+  tolerance?: number;
+  /**
+  * Output the fraction slash character (⁄) instead of the "solidus"
+  * slash (/) for fractions. Results appear like "1⁄2" instead of "1/2".
+  * Overridden by the `vulgarFractions` option.
+  */
+  fractionSlash?: boolean;
+  /**
+  * Output in Roman numerals. Provided value must be between 1 and 3999, inclusive.
+  * Decimal values will be ignored (`Math.floor` is used to remove them). Overrides
+  * all other options.
+  */
+  romanNumerals?: boolean;
+  /**
+  * String to place between the whole number and fraction parts. When not specified,
+  * defaults to `" "` for ASCII and fraction-slash fractions, and `""` for vulgar
+  * fractions (preserving the standard typographic convention of no space before
+  * vulgar fraction characters).
+  */
+  separator?: string;
+}
+/**
+* {@link FormatQuantityOptions} with all properties resolved to their
+* default values, except {@link FormatQuantityOptions.separator | separator}
+* which remains optional so that unset vs explicitly-set can be distinguished.
+*/
+type ResolvedFormatQuantityOptions = Required<Omit<FormatQuantityOptions, "separator">> & Pick<FormatQuantityOptions, "separator">;
+/**
+* Function signature of {@link formatQuantity}.
+*/
+interface FormatQuantity {
+  (qty: string | number, options?: boolean | FormatQuantityOptions): string | null;
+}
+/** Any numeric character. */
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+/** Any numeric character except '0'. */
+type NonZeroDigit = Exclude<Digit, "0">;
+/**
+* Fraction string with either one or two numeric characters in both the
+* numerator and denominator (but not two characters in the numerator while
+* the denominator only has one).
+*/
+type SimpleFraction = `${NonZeroDigit}/${NonZeroDigit}` | `${NonZeroDigit}/${NonZeroDigit}${Digit}` | `${NonZeroDigit}${Digit}/${NonZeroDigit}${Digit}`;
+/**
+* Odd numerator sixteenth fraction strings.
+*/
+type Sixteenth = `${"1" | "3" | "5" | "7" | "9" | "11" | "13" | "15"}/16`;
+/**
+* Unicode vulgar fraction code points.
+*/
+type VulgarFraction = "¼" | "½" | "¾" | "⅐" | "⅑" | "⅒" | "⅓" | "⅔" | "⅕" | "⅖" | "⅗" | "⅘" | "⅙" | "⅚" | "⅛" | "⅜" | "⅝" | "⅞";
+/** @hidden */
+type FormatQuantityTests = Record<string, ([Parameters<FormatQuantity>[0], ReturnType<FormatQuantity>] | [Parameters<FormatQuantity>[0], ReturnType<FormatQuantity>, Parameters<FormatQuantity>[1]])[]>;
+//#endregion
+//#region src/constants.d.ts
+/**
+* Default tolerance used by {@link formatQuantity} when determining if a number
+* is close enough to a fraction value to be considered equivalent.
+*/
+declare const defaultTolerance: 0.0075;
+/**
+* Default options for {@link formatQuantity}.
+*/
+declare const defaultOptions: ResolvedFormatQuantityOptions;
+/**
+* Map of vulgar fractions to their traditional ASCII equivalents.
+*/
+declare const vulgarToAsciiMap: Record<VulgarFraction, SimpleFraction>;
+/**
+* Map of "close enough" decimal values to the {@link VulgarFraction} or
+* {@link Sixteenth} fraction string matches.
+*/
+declare const fractionDecimalMatches: [number, VulgarFraction | Sixteenth][];
+//#endregion
+//#region src/formatQuantity.d.ts
+/**
+* Formats a number as Roman numerals. The number must be between
+* 1 and 3999, inclusive.
+*/
+declare const formatRomanNumerals: (qty: number) => string | null;
+/**
+* Formats a number (or string that appears to be a number)
+* as one would see it written in imperial measurements, e.g.
+* "1 1/2" instead of "1.5". To use vulgar fraction characters
+* like "½", pass `true` as the second argument. For other options
+* see {@link FormatQuantityOptions}.
+*/
+declare const formatQuantity: FormatQuantity;
+//#endregion
+export { Digit, FormatQuantity, FormatQuantityOptions, FormatQuantityTests, NonZeroDigit, ResolvedFormatQuantityOptions, SimpleFraction, Sixteenth, VulgarFraction, defaultOptions, defaultTolerance, formatQuantity, formatRomanNumerals, fractionDecimalMatches, vulgarToAsciiMap };
+//# sourceMappingURL=format-quantity.legacy-esm.d.ts.map

package/dist/format-quantity.legacy-esm.js

@@ -1,172 +1,254 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
+import { numericQuantity } from "numeric-quantity";
 
-// src/constants.ts
-var defaultTolerance = 75e-4;
-var defaultOptions = {
-  vulgarFractions: false,
-  tolerance: defaultTolerance,
-  fractionSlash: false,
-  romanNumerals: false
+//#region src/constants.ts
+/**
+* Default tolerance used by {@link formatQuantity} when determining if a number
+* is close enough to a fraction value to be considered equivalent.
+*/
+const defaultTolerance = .0075;
+/**
+* Default options for {@link formatQuantity}.
+*/
+const defaultOptions = {
+	vulgarFractions: false,
+	tolerance: defaultTolerance,
+	fractionSlash: false,
+	romanNumerals: false
 };
-var vulgarToAsciiMap = {
-  "\xBC": "1/4",
-  "\xBD": "1/2",
-  "\xBE": "3/4",
-  "\u2150": "1/7",
-  "\u2151": "1/9",
-  "\u2152": "1/10",
-  "\u2153": "1/3",
-  "\u2154": "2/3",
-  "\u2155": "1/5",
-  "\u2156": "2/5",
-  "\u2157": "3/5",
-  "\u2158": "4/5",
-  "\u2159": "1/6",
-  "\u215A": "5/6",
-  "\u215B": "1/8",
-  "\u215C": "3/8",
-  "\u215D": "5/8",
-  "\u215E": "7/8"
+/**
+* Map of vulgar fractions to their traditional ASCII equivalents.
+*/
+const vulgarToAsciiMap = {
+	"¼": "1/4",
+	"½": "1/2",
+	"¾": "3/4",
+	"⅐": "1/7",
+	"⅑": "1/9",
+	"⅒": "1/10",
+	"⅓": "1/3",
+	"⅔": "2/3",
+	"⅕": "1/5",
+	"⅖": "2/5",
+	"⅗": "3/5",
+	"⅘": "4/5",
+	"⅙": "1/6",
+	"⅚": "5/6",
+	"⅛": "1/8",
+	"⅜": "3/8",
+	"⅝": "5/8",
+	"⅞": "7/8"
 };
-var fractionDecimalMatches = [
-  [0.33, "\u2153"],
-  [0.66, "\u2154"],
-  [0.2, "\u2155"],
-  [0.4, "\u2156"],
-  [0.6, "\u2157"],
-  [0.8, "\u2158"],
-  [0.166, "\u2159"],
-  [0.833, "\u215A"],
-  [0.143, "\u2150"],
-  [0.111, "\u2151"],
-  [0.1, "\u2152"],
-  [0.125, "\u215B"],
-  [0.25, "\xBC"],
-  [0.375, "\u215C"],
-  [0.5, "\xBD"],
-  [0.625, "\u215D"],
-  [0.75, "\xBE"],
-  [0.875, "\u215E"],
-  [0.0625, "1/16"],
-  [0.1875, "3/16"],
-  [0.3125, "5/16"],
-  [0.4375, "7/16"],
-  [0.5625, "9/16"],
-  [0.6875, "11/16"],
-  [0.8125, "13/16"],
-  [0.9375, "15/16"]
+/**
+* Map of "close enough" decimal values to the {@link VulgarFraction} or
+* {@link Sixteenth} fraction string matches.
+*/
+const fractionDecimalMatches = [
+	[.33, "⅓"],
+	[.66, "⅔"],
+	[.2, "⅕"],
+	[.4, "⅖"],
+	[.6, "⅗"],
+	[.8, "⅘"],
+	[.166, "⅙"],
+	[.833, "⅚"],
+	[.143, "⅐"],
+	[.111, "⅑"],
+	[.1, "⅒"],
+	[.125, "⅛"],
+	[.25, "¼"],
+	[.375, "⅜"],
+	[.5, "½"],
+	[.625, "⅝"],
+	[.75, "¾"],
+	[.875, "⅞"],
+	[.0625, "1/16"],
+	[.1875, "3/16"],
+	[.3125, "5/16"],
+	[.4375, "7/16"],
+	[.5625, "9/16"],
+	[.6875, "11/16"],
+	[.8125, "13/16"],
+	[.9375, "15/16"]
 ];
 
-// src/formatQuantity.ts
-var closeEnough = (n1, n2, tolerance) => Math.abs(n1 - n2) < tolerance;
-var getFraction = (vulgarFractionOrSixteenth, { fractionSlash, vulgarFractions }) => {
-  var _a;
-  if (vulgarFractions) {
-    return vulgarFractionOrSixteenth;
-  }
-  const plainFraction = (_a = vulgarToAsciiMap[vulgarFractionOrSixteenth]) != null ? _a : vulgarFractionOrSixteenth;
-  if (fractionSlash) {
-    return plainFraction.replace("/", "\u2044");
-  }
-  return plainFraction;
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/formatQuantity.ts
+/**
+* Determines if two numbers are close enough to consider
+* them equal for the purposes of this package.
+*/
+const closeEnough = (n1, n2, tolerance) => Math.abs(n1 - n2) < tolerance;
+const superscriptDigits = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+const subscriptDigits = "₀₁₂₃₄₅₆₇₈₉";
+const toSuperscript = (s) => {
+	let r = "";
+	for (let i = 0; i < s.length; i++) r += superscriptDigits[+s[i]];
+	return r;
 };
-var normalizeOptions = (options) => __spreadValues(__spreadValues({}, defaultOptions), typeof options === "boolean" ? { vulgarFractions: options } : options);
-var romanNumeralValueKey = [
-  "",
-  "C",
-  "CC",
-  "CCC",
-  "CD",
-  "D",
-  "DC",
-  "DCC",
-  "DCCC",
-  "CM",
-  "",
-  "X",
-  "XX",
-  "XXX",
-  "XL",
-  "L",
-  "LX",
-  "LXX",
-  "LXXX",
-  "XC",
-  "",
-  "I",
-  "II",
-  "III",
-  "IV",
-  "V",
-  "VI",
-  "VII",
-  "VIII",
-  "IX"
-];
-var formatRomanNumerals = (qty) => {
-  if (typeof qty !== "number" || isNaN(qty)) {
-    return null;
-  }
-  if (qty < 1 || qty >= 4e3) {
-    return "";
-  }
-  const floored = Math.floor(qty);
-  const digits = `${floored}`.split("");
-  let roman = "";
-  let i = 3;
-  while (i--) {
-    roman = `${romanNumeralValueKey[+digits.pop() + i * 10] || ""}${roman}`;
-  }
-  return `${Array(+digits.join("") + 1).join("M")}${roman}`;
+const toSubscript = (s) => {
+	let r = "";
+	for (let i = 0; i < s.length; i++) r += subscriptDigits[+s[i]];
+	return r;
 };
-var formatQuantity = (qty, options = defaultOptions) => {
-  const qtyAsNumber = typeof qty === "string" ? parseFloat(qty) : qty;
-  if (isNaN(qtyAsNumber) || qtyAsNumber === null) {
-    return null;
-  }
-  if (qtyAsNumber === 0) {
-    return "";
-  }
-  const opts = normalizeOptions(options != null ? options : defaultOptions);
-  if (opts.romanNumerals) {
-    return formatRomanNumerals(qtyAsNumber);
-  }
-  const absoluteValue = Math.abs(qtyAsNumber);
-  const flooredAbsVal = Math.floor(absoluteValue);
-  const flooredAbsValStr = `${qtyAsNumber < 0 ? "-" : ""}${flooredAbsVal === 0 ? "" : `${flooredAbsVal} `}`;
-  const decimalValue = absoluteValue - flooredAbsVal;
-  if (decimalValue === 0) {
-    return `${qtyAsNumber}`;
-  }
-  for (const [num, vf] of fractionDecimalMatches) {
-    if (closeEnough(decimalValue, num, opts.tolerance)) {
-      const fraction = getFraction(vf, opts);
-      const int = fraction in vulgarToAsciiMap ? flooredAbsValStr.trim() : flooredAbsValStr;
-      return `${int}${fraction}`;
-    }
-  }
-  return `${qtyAsNumber}`;
+/**
+* Applies the `vulgarFractions` or `fractionSlash` options as necessary.
+*/
+const getFraction = (vulgarFractionOrSixteenth, { fractionSlash, vulgarFractions }) => {
+	var _vulgarToAsciiMap;
+	if (vulgarFractions) return vulgarFractionOrSixteenth;
+	const plainFraction = (_vulgarToAsciiMap = vulgarToAsciiMap[vulgarFractionOrSixteenth]) !== null && _vulgarToAsciiMap !== void 0 ? _vulgarToAsciiMap : vulgarFractionOrSixteenth;
+	if (fractionSlash) {
+		const [num, den] = plainFraction.split("/");
+		return `${toSuperscript(num)}⁄${toSubscript(den)}`;
+	}
+	return plainFraction;
 };
-export {
-  defaultOptions,
-  defaultTolerance,
-  formatQuantity,
-  fractionDecimalMatches,
-  vulgarToAsciiMap
+/**
+* Merges options object with default options, converting boolean to object if necessary.
+*/
+const normalizeOptions = (options) => _objectSpread2(_objectSpread2({}, defaultOptions), typeof options === "boolean" ? { vulgarFractions: options } : options);
+const romanNumeralValueKey = [
+	"",
+	"C",
+	"CC",
+	"CCC",
+	"CD",
+	"D",
+	"DC",
+	"DCC",
+	"DCCC",
+	"CM",
+	"",
+	"X",
+	"XX",
+	"XXX",
+	"XL",
+	"L",
+	"LX",
+	"LXX",
+	"LXXX",
+	"XC",
+	"",
+	"I",
+	"II",
+	"III",
+	"IV",
+	"V",
+	"VI",
+	"VII",
+	"VIII",
+	"IX"
+];
+/**
+* Formats a number as Roman numerals. The number must be between
+* 1 and 3999, inclusive.
+*/
+const formatRomanNumerals = (qty) => {
+	if (typeof qty !== "number" || isNaN(qty)) return null;
+	if (qty < 1 || qty >= 4e3) return "";
+	const digits = `${Math.floor(qty)}`.split("");
+	let roman = "";
+	let i = 3;
+	while (i--) roman = `${romanNumeralValueKey[+digits.pop() + i * 10] || ""}${roman}`;
+	return `${Array(+digits.join("") + 1).join("M")}${roman}`;
 };
+/**
+* Formats a number (or string that appears to be a number)
+* as one would see it written in imperial measurements, e.g.
+* "1 1/2" instead of "1.5". To use vulgar fraction characters
+* like "½", pass `true` as the second argument. For other options
+* see {@link FormatQuantityOptions}.
+*/
+const formatQuantity = (qty, options = defaultOptions) => {
+	const qtyAsNumber = typeof qty === "string" ? numericQuantity(qty, {
+		round: false,
+		allowTrailingInvalid: true
+	}) : qty;
+	if (isNaN(qtyAsNumber) || qtyAsNumber === null) return null;
+	if (qtyAsNumber === 0) return "";
+	const opts = normalizeOptions(options !== null && options !== void 0 ? options : defaultOptions);
+	if (opts.romanNumerals) return formatRomanNumerals(qtyAsNumber);
+	const absoluteValue = Math.abs(qtyAsNumber);
+	const flooredAbsVal = Math.floor(absoluteValue);
+	const sign = qtyAsNumber < 0 ? "-" : "";
+	const wholeStr = flooredAbsVal === 0 ? "" : `${flooredAbsVal}`;
+	const decimalValue = absoluteValue - flooredAbsVal;
+	if (decimalValue === 0) return `${qtyAsNumber}`;
+	for (const [num, vf] of fractionDecimalMatches) if (closeEnough(decimalValue, num, opts.tolerance)) {
+		var _opts$separator;
+		const fraction = getFraction(vf, opts);
+		const isVulgar = fraction in vulgarToAsciiMap;
+		return `${sign}${wholeStr}${wholeStr ? (_opts$separator = opts.separator) !== null && _opts$separator !== void 0 ? _opts$separator : isVulgar ? "" : " " : ""}${fraction}`;
+	}
+	return `${qtyAsNumber}`;
+};
+
+//#endregion
+export { defaultOptions, defaultTolerance, formatQuantity, formatRomanNumerals, fractionDecimalMatches, vulgarToAsciiMap };
 //# sourceMappingURL=format-quantity.legacy-esm.js.map

package/dist/format-quantity.legacy-esm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/constants.ts","../src/formatQuantity.ts"],"sourcesContent":["import type {\n  FormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Default tolerance used by {@link formatQuantity} when determining if a number\n * is close enough to a fraction value to be considered equivalent.\n */\nexport const defaultTolerance = 0.0075 as const;\n\n/**\n * Default options for {@link formatQuantity}.\n */\nexport const defaultOptions = {\n  vulgarFractions: false,\n  tolerance: defaultTolerance,\n  fractionSlash: false,\n  romanNumerals: false,\n} as const satisfies Required<FormatQuantityOptions>;\n\n/**\n * Map of vulgar fractions to their traditional ASCII equivalents.\n */\nexport const vulgarToAsciiMap = {\n  '¼': '1/4',\n  '½': '1/2',\n  '¾': '3/4',\n  '⅐': '1/7',\n  '⅑': '1/9',\n  '⅒': '1/10',\n  '⅓': '1/3',\n  '⅔': '2/3',\n  '⅕': '1/5',\n  '⅖': '2/5',\n  '⅗': '3/5',\n  '⅘': '4/5',\n  '⅙': '1/6',\n  '⅚': '5/6',\n  '⅛': '1/8',\n  '⅜': '3/8',\n  '⅝': '5/8',\n  '⅞': '7/8',\n} as const satisfies Record<VulgarFraction, SimpleFraction>;\n\n/**\n * Map of \"close enough\" decimal values to the {@link VulgarFraction} or\n * {@link Sixteenth} fraction string matches.\n */\nexport const fractionDecimalMatches = [\n  [0.33, '⅓'],\n  [0.66, '⅔'],\n  [0.2, '⅕'],\n  [0.4, '⅖'],\n  [0.6, '⅗'],\n  [0.8, '⅘'],\n  [0.166, '⅙'],\n  [0.833, '⅚'],\n  [0.143, '⅐'],\n  [0.111, '⅑'],\n  [0.1, '⅒'],\n  [0.125, '⅛'],\n  [0.25, '¼'],\n  [0.375, '⅜'],\n  [0.5, '½'],\n  [0.625, '⅝'],\n  [0.75, '¾'],\n  [0.875, '⅞'],\n  [0.0625, '1/16'],\n  [0.1875, '3/16'],\n  [0.3125, '5/16'],\n  [0.4375, '7/16'],\n  [0.5625, '9/16'],\n  [0.6875, '11/16'],\n  [0.8125, '13/16'],\n  [0.9375, '15/16'],\n] satisfies [number, VulgarFraction | Sixteenth][];\n","import {\n  defaultOptions,\n  fractionDecimalMatches,\n  vulgarToAsciiMap,\n} from './constants';\nimport type {\n  FormatQuantity,\n  FormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Determines if two numbers are close enough to consider\n * them equal for the purposes of this package.\n */\nconst closeEnough = (n1: number, n2: number, tolerance: number) =>\n  Math.abs(n1 - n2) < tolerance;\n\n/**\n * Applies the `vulgarFractions` or `fractionSlash` options as necessary.\n */\nconst getFraction = (\n  vulgarFractionOrSixteenth: VulgarFraction | Sixteenth,\n  { fractionSlash, vulgarFractions }: FormatQuantityOptions\n) => {\n  if (vulgarFractions) {\n    return vulgarFractionOrSixteenth;\n  }\n\n  const plainFraction: SimpleFraction =\n    vulgarToAsciiMap[vulgarFractionOrSixteenth as VulgarFraction] ??\n    vulgarFractionOrSixteenth;\n\n  if (fractionSlash) {\n    return plainFraction.replace('/', '⁄');\n  }\n\n  return plainFraction;\n};\n\n/**\n * Merges options object with default options, converting boolean to object if necessary.\n */\nconst normalizeOptions = (\n  options: Parameters<FormatQuantity>[1]\n): Required<FormatQuantityOptions> => ({\n  ...defaultOptions,\n  ...(typeof options === 'boolean' ? { vulgarFractions: options } : options),\n});\n\n// prettier-ignore\nconst romanNumeralValueKey = [\n  \"\", \"C\", \"CC\", \"CCC\", \"CD\", \"D\", \"DC\", \"DCC\", \"DCCC\", \"CM\",\n  \"\", \"X\", \"XX\", \"XXX\", \"XL\", \"L\", \"LX\", \"LXX\", \"LXXX\", \"XC\",\n  \"\", \"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\", \"VIII\", \"IX\",\n] as const;\n\n/**\n * Formats a number as Roman numerals. The number must be between\n * 1 and 3999, inclusive.\n */\nexport const formatRomanNumerals = (qty: number) => {\n  if (typeof qty !== 'number' || isNaN(qty)) {\n    return null;\n  }\n\n  if (qty < 1 || qty >= 4000) {\n    return '';\n  }\n\n  const floored = Math.floor(qty);\n\n  const digits = `${floored}`.split('');\n  let roman = '';\n  let i = 3;\n  while (i--) {\n    roman = `${romanNumeralValueKey[+digits.pop()! + i * 10] || ''}${roman}`;\n  }\n\n  return `${Array(+digits.join('') + 1).join('M')}${roman}`;\n};\n\n/**\n * Formats a number (or string that appears to be a number)\n * as one would see it written in imperial measurements, e.g.\n * \"1 1/2\" instead of \"1.5\". To use vulgar fraction characters\n * like \"½\", pass `true` as the second argument. For other options\n * see {@link FormatQuantityOptions}.\n */\nexport const formatQuantity: FormatQuantity = (\n  qty,\n  options = defaultOptions\n) => {\n  // TODO: use numericQuantity instead of parseFloat?\n  const qtyAsNumber = typeof qty === 'string' ? parseFloat(qty) : qty;\n\n  // Return `null` if input is not number-like.\n  if (isNaN(qtyAsNumber) || qtyAsNumber === null) {\n    return null;\n  }\n\n  // Return an empty string if the value is zero.\n  if (qtyAsNumber === 0) {\n    return '';\n  }\n\n  // The default options parameter in the function signature only takes effect\n  // if the parameter is `undefined`. The nullish coalescing operator below\n  // covers the `null` case.\n  const opts = normalizeOptions(options ?? defaultOptions);\n\n  if (opts.romanNumerals) {\n    return formatRomanNumerals(qtyAsNumber);\n  }\n\n  const absoluteValue = Math.abs(qtyAsNumber);\n  const flooredAbsVal = Math.floor(absoluteValue);\n  const flooredAbsValStr = `${qtyAsNumber < 0 ? '-' : ''}${\n    flooredAbsVal === 0 ? '' : `${flooredAbsVal} `\n  }`;\n  const decimalValue = absoluteValue - flooredAbsVal;\n\n  // For integers just return the given value as a string.\n  if (decimalValue === 0) {\n    return `${qtyAsNumber}`;\n  }\n\n  for (const [num, vf] of fractionDecimalMatches) {\n    if (closeEnough(decimalValue, num, opts.tolerance)) {\n      const fraction = getFraction(vf, opts);\n      const int =\n        fraction in vulgarToAsciiMap\n          ? flooredAbsValStr.trim()\n          : flooredAbsValStr;\n      return `${int}${fraction}`;\n    }\n  }\n\n  return `${qtyAsNumber}`;\n};\n"],"mappings":"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","names":[]}
+{"version":3,"file":"format-quantity.legacy-esm.js","names":[],"sources":["../src/constants.ts","../src/formatQuantity.ts"],"sourcesContent":["import type {\n  ResolvedFormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Default tolerance used by {@link formatQuantity} when determining if a number\n * is close enough to a fraction value to be considered equivalent.\n */\nexport const defaultTolerance = 0.0075 as const;\n\n/**\n * Default options for {@link formatQuantity}.\n */\nexport const defaultOptions: ResolvedFormatQuantityOptions = {\n  vulgarFractions: false,\n  tolerance: defaultTolerance,\n  fractionSlash: false,\n  romanNumerals: false,\n} as const;\n\n/**\n * Map of vulgar fractions to their traditional ASCII equivalents.\n */\nexport const vulgarToAsciiMap: Record<VulgarFraction, SimpleFraction> = {\n  '¼': '1/4',\n  '½': '1/2',\n  '¾': '3/4',\n  '⅐': '1/7',\n  '⅑': '1/9',\n  '⅒': '1/10',\n  '⅓': '1/3',\n  '⅔': '2/3',\n  '⅕': '1/5',\n  '⅖': '2/5',\n  '⅗': '3/5',\n  '⅘': '4/5',\n  '⅙': '1/6',\n  '⅚': '5/6',\n  '⅛': '1/8',\n  '⅜': '3/8',\n  '⅝': '5/8',\n  '⅞': '7/8',\n} as const;\n\n/**\n * Map of \"close enough\" decimal values to the {@link VulgarFraction} or\n * {@link Sixteenth} fraction string matches.\n */\nexport const fractionDecimalMatches: [number, VulgarFraction | Sixteenth][] = [\n  [0.33, '⅓'],\n  [0.66, '⅔'],\n  [0.2, '⅕'],\n  [0.4, '⅖'],\n  [0.6, '⅗'],\n  [0.8, '⅘'],\n  [0.166, '⅙'],\n  [0.833, '⅚'],\n  [0.143, '⅐'],\n  [0.111, '⅑'],\n  [0.1, '⅒'],\n  [0.125, '⅛'],\n  [0.25, '¼'],\n  [0.375, '⅜'],\n  [0.5, '½'],\n  [0.625, '⅝'],\n  [0.75, '¾'],\n  [0.875, '⅞'],\n  [0.0625, '1/16'],\n  [0.1875, '3/16'],\n  [0.3125, '5/16'],\n  [0.4375, '7/16'],\n  [0.5625, '9/16'],\n  [0.6875, '11/16'],\n  [0.8125, '13/16'],\n  [0.9375, '15/16'],\n] as const;\n","import { numericQuantity } from 'numeric-quantity';\nimport {\n  defaultOptions,\n  fractionDecimalMatches,\n  vulgarToAsciiMap,\n} from './constants';\nimport type {\n  FormatQuantity,\n  FormatQuantityOptions,\n  ResolvedFormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\n/**\n * Determines if two numbers are close enough to consider\n * them equal for the purposes of this package.\n */\nconst closeEnough = (n1: number, n2: number, tolerance: number) =>\n  Math.abs(n1 - n2) < tolerance;\n\nconst superscriptDigits = '⁰¹²³⁴⁵⁶⁷⁸⁹';\nconst subscriptDigits = '₀₁₂₃₄₅₆₇₈₉';\n\nconst toSuperscript = (s: string) => {\n  let r = '';\n  for (let i = 0; i < s.length; i++) r += superscriptDigits[+s[i]];\n  return r;\n};\nconst toSubscript = (s: string) => {\n  let r = '';\n  for (let i = 0; i < s.length; i++) r += subscriptDigits[+s[i]];\n  return r;\n};\n\n/**\n * Applies the `vulgarFractions` or `fractionSlash` options as necessary.\n */\nconst getFraction = (\n  vulgarFractionOrSixteenth: VulgarFraction | Sixteenth,\n  { fractionSlash, vulgarFractions }: FormatQuantityOptions\n) => {\n  if (vulgarFractions) {\n    return vulgarFractionOrSixteenth;\n  }\n\n  const plainFraction: SimpleFraction =\n    vulgarToAsciiMap[vulgarFractionOrSixteenth as VulgarFraction] ??\n    vulgarFractionOrSixteenth;\n\n  if (fractionSlash) {\n    const [num, den] = plainFraction.split('/');\n    return `${toSuperscript(num)}⁄${toSubscript(den)}`;\n  }\n\n  return plainFraction;\n};\n\n/**\n * Merges options object with default options, converting boolean to object if necessary.\n */\nconst normalizeOptions = (\n  options: Parameters<FormatQuantity>[1]\n): ResolvedFormatQuantityOptions => ({\n  ...defaultOptions,\n  ...(typeof options === 'boolean' ? { vulgarFractions: options } : options),\n});\n\n// prettier-ignore\nconst romanNumeralValueKey = [\n  \"\", \"C\", \"CC\", \"CCC\", \"CD\", \"D\", \"DC\", \"DCC\", \"DCCC\", \"CM\",\n  \"\", \"X\", \"XX\", \"XXX\", \"XL\", \"L\", \"LX\", \"LXX\", \"LXXX\", \"XC\",\n  \"\", \"I\", \"II\", \"III\", \"IV\", \"V\", \"VI\", \"VII\", \"VIII\", \"IX\",\n] as const;\n\n/**\n * Formats a number as Roman numerals. The number must be between\n * 1 and 3999, inclusive.\n */\nexport const formatRomanNumerals = (qty: number): string | null => {\n  if (typeof qty !== 'number' || isNaN(qty)) {\n    return null;\n  }\n\n  if (qty < 1 || qty >= 4000) {\n    return '';\n  }\n\n  const floored = Math.floor(qty);\n\n  const digits = `${floored}`.split('');\n  let roman = '';\n  let i = 3;\n  while (i--) {\n    roman = `${romanNumeralValueKey[+digits.pop()! + i * 10] || ''}${roman}`;\n  }\n\n  return `${Array(+digits.join('') + 1).join('M')}${roman}`;\n};\n\n/**\n * Formats a number (or string that appears to be a number)\n * as one would see it written in imperial measurements, e.g.\n * \"1 1/2\" instead of \"1.5\". To use vulgar fraction characters\n * like \"½\", pass `true` as the second argument. For other options\n * see {@link FormatQuantityOptions}.\n */\nexport const formatQuantity: FormatQuantity = (\n  qty,\n  options = defaultOptions\n) => {\n  const qtyAsNumber =\n    typeof qty === 'string'\n      ? numericQuantity(qty, { round: false, allowTrailingInvalid: true })\n      : qty;\n\n  // Return `null` if input is not number-like.\n  if (isNaN(qtyAsNumber) || qtyAsNumber === null) {\n    return null;\n  }\n\n  // Return an empty string if the value is zero.\n  // TODO: Consider a `zeroDisplay` option (e.g. `{ zeroDisplay: \"0\" }`) so\n  // callers outside the recipe-ingredient use case can get \"0\" instead of \"\".\n  if (qtyAsNumber === 0) {\n    return '';\n  }\n\n  // The default options parameter in the function signature only takes effect\n  // if the parameter is `undefined`. The nullish coalescing operator below\n  // covers the `null` case.\n  const opts = normalizeOptions(options ?? defaultOptions);\n\n  if (opts.romanNumerals) {\n    return formatRomanNumerals(qtyAsNumber);\n  }\n\n  const absoluteValue = Math.abs(qtyAsNumber);\n  const flooredAbsVal = Math.floor(absoluteValue);\n  const sign = qtyAsNumber < 0 ? '-' : '';\n  const wholeStr = flooredAbsVal === 0 ? '' : `${flooredAbsVal}`;\n  const decimalValue = absoluteValue - flooredAbsVal;\n\n  // For integers just return the given value as a string.\n  if (decimalValue === 0) {\n    return `${qtyAsNumber}`;\n  }\n\n  for (const [num, vf] of fractionDecimalMatches) {\n    if (closeEnough(decimalValue, num, opts.tolerance)) {\n      const fraction = getFraction(vf, opts);\n      const isVulgar = fraction in vulgarToAsciiMap;\n      const sep = wholeStr\n        ? (opts.separator ?? (isVulgar ? '' : ' '))\n        : '';\n      return `${sign}${wholeStr}${sep}${fraction}`;\n    }\n  }\n\n  return `${qtyAsNumber}`;\n};\n"],"mappings":"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"}