format-quantity 2.0.1 → 2.1.0-beta.0

package/README.md

@@ -1,50 +1,56 @@
 # format-quantity
 
-[![npm version](https://badge.fury.io/js/format-quantity.svg)](//npmjs.com/package/format-quantity)
-![workflow status](https://github.com/jakeboone02/format-quantity/workflows/Continuous%20Integration/badge.svg)
-[![codecov.io](https://codecov.io/github/jakeboone02/format-quantity/coverage.svg?branch=master)](https://codecov.io/github/jakeboone02/format-quantity?branch=master)
+[![npm][badge-npm]](https://www.npmjs.com/package/format-quantity)
+![workflow status](https://github.com/jakeboone02/format-quantity/actions/workflows/main.yml/badge.svg)
+[![codecov.io](https://codecov.io/github/jakeboone02/format-quantity/coverage.svg?branch=main)](https://codecov.io/github/jakeboone02/format-quantity?branch=main)
 [![downloads](https://img.shields.io/npm/dm/format-quantity.svg)](http://npm-stat.com/charts.html?package=format-quantity&from=2015-08-01)
 [![MIT License](https://img.shields.io/npm/l/format-quantity.svg)](http://opensource.org/licenses/MIT)
 
-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.
+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".
 
-For the inverse operation, converting a string (which may include mixed numbers or vulgar fractions) to a `number`, check out [numeric-quantity](https://www.npmjs.com/package/numeric-quantity) or, if you're interested in parsing recipe ingredient strings, try [parse-ingredient](https://www.npmjs.com/package/parse-ingredient).
+Features:
 
-## Installation
+- To use vulgar fraction characters like "⅞", pass `true` as the second argument (see other [options](#options), like Roman numerals, below).
+- The return value will be `null` if the first argument is neither a number nor a string that evaluates to a number using `parseFloat`.
+- The return value will be an empty string (`""`) if the first argument is `0` or `"0"`, which is done to fit the primary use case of formatting recipe ingredient quantities.
 
-### npm
+> _For the inverse operation—converting a string to a `number`—check out [numeric-quantity](https://www.npmjs.com/package/numeric-quantity). It handles mixed numbers, vulgar fractions, comma/underscore separators, and Roman numerals._
+>
+> _If you're interested in parsing recipe ingredient strings, try [parse-ingredient](https://www.npmjs.com/package/parse-ingredient)._
 
-```shell
-# npm
-npm i format-quantity
+## Usage
+
+### Installed
+
+```js
+import { formatQuantity } from 'format-quantity';
 
-# yarn
-yarn add format-quantity
+formatQuantity(1.5); // "1 1/2"
+formatQuantity(2.66); // "2 2/3"
+formatQuantity(3.875, true); // "3⅞"
 ```
 
-### Browser
+### CDN
 
-In the browser, all exports including the `formatQuantity` function are available on the global object `FormatQuantity`.
+As an ES module:
 
 ```html
-<script src="https://unpkg.com/format-quantity"></script>
-<script>
-  console.log(FormatQuantity.formatQuantity(10.5)); // "10 1/2"
+<script type="module">
+  import { formatQuantity } from 'https://cdn.jsdelivr.net/npm/format-quantity/+esm';
+
+  console.log(formatQuantity(10.5)); // "10 1/2"
 </script>
 ```
 
-## Usage
-
-```js
-import { formatQuantity } from 'format-quantity';
+As UMD (all exports are properties of the global object `FormatQuantity`):
 
-formatQuantity(1.5); // "1 1/2"
-formatQuantity(2.66); // "2 2/3"
-formatQuantity(3.875, true); // "3⅞"
+```html
+<script src="https://unpkg.com/format-quantity"></script>
+<script>
+  console.log(FormatQuantity.formatQuantity(10.5)); // "10 1/2"
+</script>
 ```
 
-The return value will be `null` if the provided argument is not a number or a string that evaluates to a number using `parseFloat`. The return value will be an empty string (`""`) if the provided argument is `0` or `"0"` (this is done to fit the primary use case of recipe ingredient quantities).
-
 ## Options
 
 The second parameter to `formatQuantity` can be a `boolean` value or an options object.
@@ -65,44 +71,65 @@ formatQuantity(3.875, true); // "3⅞"
 
 Note: `formatQuantity` supports sixteenths, but no vulgar fraction characters exist for that denomination. Therefore the `vulgarFractions` option has no effect if the fraction portion of the final string is an odd numerator over a denominator of `16`.
 
+### `fractionSlash`
+
+| Type      | Default |
+| --------- | ------: |
+| `boolean` | `false` |
+
+Uses the [fraction slash character](<https://en.wikipedia.org/wiki/Slash_(punctuation)#Fractions>) (`"\u2044"`) to separate the numerator and denominator instead of the regular "solidus" slash (`"\u002f"`). This option is ignored if the `vulgarFractions` option is also `true`.
+
+```js
+formatQuantity(3.875, { fractionSlash: true }); // "3 7⁄8"
+formatQuantity(3.875, { fractionSlash: true, vulgarFractions: true }); // "3⅞"
+```
+
 ### `tolerance`
 
 | Type     |  Default |
 | -------- | -------: |
 | `number` | `0.0075` |
 
-This option determines how close the decimal portion of a number has to be to the actual quotient of a fraction to be considered a match. For example, consider the fraction 1⁄3: `1 ÷ 3 = 0.3333...` repeating forever. The number `0.333` (333 thousandths) is not equivalent to 1⁄3, but it's very close. So even though `0.333 !== (1 / 3)`, `formatQuantity(0.333)` will return `"1/3"` the same as `formatQuantity(1/3)`.
+This option determines how close the decimal portion of a number has to be to the actual quotient of a fraction to be considered a match. For example, consider the fraction 1⁄3: $1 \div 3 = 0.\overline{333}$, repeating forever. The number `0.333` (exactly 333 thousandths) is not equivalent to 1⁄3, but it's very close. So even though $0.333 \neq 1 \div 3$, both `formatQuantity(0.333)` and `formatQuantity(1/3)` will return `"1/3"`.
 
-A lower tolerance increases the likelihood that `formatQuantity` will return a decimal representation instead of a fraction or mixed number since the matching algorithm will be stricter. An greater tolerance increases the likelihood that `formatQuantity` will return a fraction or mixed number, but at the risk of arbitrarily matching an incorrect fraction simply because it gets evaluated first (see [`src/index.ts`](src/index.ts) for the actual order of evaluation).
+A lower tolerance increases the likelihood that `formatQuantity` will return a decimal representation instead of a fraction or mixed number since the matching algorithm will be stricter. An higher tolerance increases the likelihood that `formatQuantity` will return a fraction or mixed number, but at the risk of arbitrarily matching an incorrect fraction simply because it gets evaluated first (the export `fractionDecimalMatches` defines the order of evaluation).
 
 ```js
 // Low tolerance - returns a decimal since 0.333 is not close enough to 1/3
 formatQuantity(0.333, { tolerance: 0.00001 }); // "0.333"
-// High tolerance - matches "1/3" even for "3/10"
+// High tolerance - matches "1/3" even for 3/10
 formatQuantity(0.3, { tolerance: 0.1 }); // "1/3"
-// Way too high tolerance - incorrect result because thirds get evaluated before halves
+// *Way* too high tolerance - incorrect result because thirds get evaluated before halves
 formatQuantity(0.5, { tolerance: 0.5 }); // "1/3"
 ```
 
-### `fractionSlash`
+### `romanNumerals`
 
 | Type      | Default |
 | --------- | ------: |
 | `boolean` | `false` |
 
-Uses the [fraction slash character](<https://en.wikipedia.org/wiki/Slash_(punctuation)#Fractions>) (`"\u2044"`) to separate the numerator and denominator instead of the regular "solidus" slash (`"\u002f"`). This option is ignored if the `vulgarFractions` option is also `true`.
+Coerces the number into an integer using `Math.floor`, then formats the value as Roman numerals. The algorithm uses strict, modern rules, so the number must be between 1 and 3999 (inclusive).
+
+When this option is `true`, all other options are ignored.
 
 ```js
-formatQuantity(3.875, { fractionSlash: true }); // "3 7⁄8"
-formatQuantity(3.875, { fractionSlash: true, vulgarFractions: true }); // "3⅞"
+formatQuantity(1214, { romanNumerals: true }); // "MCCXIV"
+formatQuantity(12.14, { romanNumerals: true, vulgarFractions: true }); // "XII"
 ```
 
 ## Other exports
 
-| Name                     | Type                         | Description                                                                                                                                                 |
-| ------------------------ | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `defaultTolerance`       | `number`                     | `0.0075`                                                                                                                                                    |
-| `fractionDecimalMatches` | `[number, VulgarFraction][]` | List of fractions and the decimal values that are close enough to match them (inputs are evaluated against the decimal values in the order of this array)   |
-| `vulgarToPlainMap`       | `object`                     | Map of vulgar fraction characters to their equivalent ASCII strings (`"⅓"` to `"1/3"`, `"⅞"` to `"7/8"`, etc.)                                              |
-| `FormatQuantityOptions`  | `interface`                  | Shape of `formatQuantity`'s second parameter, if not a `boolean` value                                                                                      |
-| `VulgarFraction`         | `type`                       | The set of [vulgar fraction characters](https://en.wikipedia.org/wiki/Number_Forms) (`"\u00bc"`, `"\u00bd"`, `"\u00be"`, and `"\u2150"` through `"\u215e"`) |
+| Name                     | Type                                                 | Description                                                                                                                                                 |
+| ------------------------ | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `defaultTolerance`       | `number`                                             | `0.0075`                                                                                                                                                    |
+| `defaultOptions`         | `type`                                               | Object representing the default options                                                                                                                     |
+| `fractionDecimalMatches` | <code>[number, VulgarFraction \| Sixteenth][]</code> | List of decimal values that are close enough to match the associated fraction (inputs are evaluated against the decimal values in the order of this array)  |
+| `vulgarToAsciiMap`       | `object`                                             | Map of vulgar fraction characters to their equivalent ASCII strings (`"⅓"` to `"1/3"`, `"⅞"` to `"7/8"`, etc.)                                              |
+| `formatRomanNumerals`    | `function`                                           | Formats a number as Roman numerals (used internally by `formatQuantity` when the `romanNumerals` option is `true`)                                          |
+| `FormatQuantityOptions`  | `interface`                                          | Shape of `formatQuantity`'s second parameter (if not a `boolean` value)                                                                                     |
+| `SimpleFraction`         | `type`                                               | String template type for valid (positive, no division by zero) ASCII fraction strings with either one or two digits in the numerator and denominator each   |
+| `VulgarFraction`         | `type`                                               | The set of [vulgar fraction characters](https://en.wikipedia.org/wiki/Number_Forms) (`"\u00bc"`, `"\u00bd"`, `"\u00be"`, and `"\u2150"` through `"\u215e"`) |
+| `Sixteenth`              | `type`                                               | Union type of all ASCII representations of odd-numbered sixteenth fractions less than one, (`"1/16"`, `"3/16"`, etc.)                                       |
+
+[badge-npm]: https://img.shields.io/npm/v/numeric-quantity.svg?cacheSeconds=3600&logo=npm

package/dist/cjs/format-quantity.cjs.development.js

@@ -0,0 +1,192 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  defaultOptions: () => defaultOptions,
+  defaultTolerance: () => defaultTolerance,
+  formatQuantity: () => formatQuantity,
+  fractionDecimalMatches: () => fractionDecimalMatches,
+  vulgarToAsciiMap: () => vulgarToAsciiMap
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var defaultTolerance = 75e-4;
+var 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"
+};
+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"]
+];
+
+// src/formatQuantity.ts
+var closeEnough = (n1, n2, tolerance) => Math.abs(n1 - n2) < tolerance;
+var getFraction = (vulgarFractionOrSixteenth, { fractionSlash, vulgarFractions }) => {
+  if (vulgarFractions) {
+    return vulgarFractionOrSixteenth;
+  }
+  const plainFraction = vulgarToAsciiMap[vulgarFractionOrSixteenth] ?? vulgarFractionOrSixteenth;
+  if (fractionSlash) {
+    return plainFraction.replace("/", "\u2044");
+  }
+  return plainFraction;
+};
+var normalizeOptions = (options) => ({
+  ...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}`;
+};
+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 ?? 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 = Object.hasOwn(vulgarToAsciiMap, fraction) ? flooredAbsValStr.trim() : flooredAbsValStr;
+      return `${int}${fraction}`;
+    }
+  }
+  return `${qtyAsNumber}`;
+};
+
+// src/index.ts
+var src_default = formatQuantity;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultOptions,
+  defaultTolerance,
+  formatQuantity,
+  fractionDecimalMatches,
+  vulgarToAsciiMap
+});
+//# sourceMappingURL=format-quantity.cjs.development.js.map

package/dist/cjs/format-quantity.cjs.development.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/constants.ts","../../src/formatQuantity.ts"],"sourcesContent":["import { formatQuantity } from './formatQuantity';\nexport * from './constants';\nexport * from './types';\nexport { formatQuantity };\nexport default formatQuantity;\n","import type {\n  FormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\nexport const defaultTolerance = 0.0075 as const;\n\nexport const defaultOptions = {\n  vulgarFractions: false,\n  tolerance: defaultTolerance,\n  fractionSlash: false,\n  romanNumerals: false,\n} satisfies Required<FormatQuantityOptions>;\n\n/**\n * A map of vulgar or simple sixteenth fractions to their traditional ASCII\n * equivalents. Sixteenths map to themselves.\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} satisfies Record<VulgarFraction, SimpleFraction>;\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\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\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  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 the [documentation](https://jakeboone02.github.io/format-quantity/).\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 = Object.hasOwn(vulgarToAsciiMap, fraction)\n        ? flooredAbsValStr.trim()\n        : flooredAbsValStr;\n      return `${int}${fraction}`;\n    }\n  }\n\n  return `${qtyAsNumber}`;\n};\n"],"mappings":"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","names":[]}

package/dist/cjs/format-quantity.cjs.production.js

@@ -0,0 +1,2 @@
+"use strict";var l=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var X=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var d=(t,o)=>{for(var r in o)l(t,r,{get:o[r],enumerable:!0})},y=(t,o,r,a)=>{if(o&&typeof o=="object"||typeof o=="function")for(let e of X(o))!b.call(t,e)&&e!==r&&l(t,e,{get:()=>o[e],enumerable:!(a=C(o,e))||a.enumerable});return t};var I=t=>y(l({},"__esModule",{value:!0}),t);var N={};d(N,{default:()=>Q,defaultOptions:()=>n,defaultTolerance:()=>D,formatQuantity:()=>c,fractionDecimalMatches:()=>u,vulgarToAsciiMap:()=>i});module.exports=I(N);var D=.0075,n={vulgarFractions:!1,tolerance:.0075,fractionSlash:!1,romanNumerals:!1},i={"\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"},u=[[.33,"\u2153"],[.66,"\u2154"],[.2,"\u2155"],[.4,"\u2156"],[.6,"\u2157"],[.8,"\u2158"],[.166,"\u2159"],[.833,"\u215A"],[.143,"\u2150"],[.111,"\u2151"],[.1,"\u2152"],[.125,"\u215B"],[.25,"\xBC"],[.375,"\u215C"],[.5,"\xBD"],[.625,"\u215D"],[.75,"\xBE"],[.875,"\u215E"],[.0625,"1/16"],[.1875,"3/16"],[.3125,"5/16"],[.4375,"7/16"],[.5625,"9/16"],[.6875,"11/16"],[.8125,"13/16"],[.9375,"15/16"]];var g=(t,o,r)=>Math.abs(t-o)<r,h=(t,{fractionSlash:o,vulgarFractions:r})=>{if(r)return t;let a=i[t]??t;return o?a.replace("/","\u2044"):a},x=t=>({...n,...typeof t=="boolean"?{vulgarFractions:t}:t}),$=["","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"],M=t=>{if(typeof t!="number"||isNaN(t))return null;if(t<1||t>=4e3)return"";let r=`${Math.floor(t)}`.split(""),a="",e=3;for(;e--;)a=`${$[+r.pop()+e*10]||""}${a}`;return`${Array(+r.join("")+1).join("M")}${a}`},c=(t,o=n)=>{let r=typeof t=="string"?parseFloat(t):t;if(isNaN(r)||r===null)return null;if(r===0)return"";let a=x(o??n);if(a.romanNumerals)return M(r);let e=Math.abs(r),s=Math.floor(e),m=`${r<0?"-":""}${s===0?"":`${s} `}`,f=e-s;if(f===0)return`${r}`;for(let[F,V]of u)if(g(f,F,a.tolerance)){let p=h(V,a);return`${Object.hasOwn(i,p)?m.trim():m}${p}`}return`${r}`};var Q=c;0&&(module.exports={defaultOptions,defaultTolerance,formatQuantity,fractionDecimalMatches,vulgarToAsciiMap});
+//# sourceMappingURL=format-quantity.cjs.production.js.map

package/dist/cjs/format-quantity.cjs.production.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/constants.ts","../../src/formatQuantity.ts"],"sourcesContent":["import { formatQuantity } from './formatQuantity';\nexport * from './constants';\nexport * from './types';\nexport { formatQuantity };\nexport default formatQuantity;\n","import type {\n  FormatQuantityOptions,\n  SimpleFraction,\n  Sixteenth,\n  VulgarFraction,\n} from './types';\n\nexport const defaultTolerance = 0.0075 as const;\n\nexport const defaultOptions = {\n  vulgarFractions: false,\n  tolerance: defaultTolerance,\n  fractionSlash: false,\n  romanNumerals: false,\n} satisfies Required<FormatQuantityOptions>;\n\n/**\n * A map of vulgar or simple sixteenth fractions to their traditional ASCII\n * equivalents. Sixteenths map to themselves.\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} satisfies Record<VulgarFraction, SimpleFraction>;\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\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\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  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 the [documentation](https://jakeboone02.github.io/format-quantity/).\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 = Object.hasOwn(vulgarToAsciiMap, fraction)\n        ? flooredAbsValStr.trim()\n        : flooredAbsValStr;\n      return `${int}${fraction}`;\n    }\n  }\n\n  return `${qtyAsNumber}`;\n};\n"],"mappings":"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","names":["src_exports","__export","src_default","defaultOptions","defaultTolerance","formatQuantity","fractionDecimalMatches","vulgarToAsciiMap","__toCommonJS","defaultTolerance","defaultOptions","vulgarToAsciiMap","fractionDecimalMatches","closeEnough","n1","n2","tolerance","getFraction","vulgarFractionOrSixteenth","fractionSlash","vulgarFractions","plainFraction","vulgarToAsciiMap","normalizeOptions","options","defaultOptions","romanNumeralValueKey","formatRomanNumerals","qty","digits","roman","i","formatQuantity","qtyAsNumber","opts","absoluteValue","flooredAbsVal","flooredAbsValStr","decimalValue","num","vf","fractionDecimalMatches","fraction","src_default","formatQuantity"]}

package/dist/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict';
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./format-quantity.cjs.production.js');
+} else {
+  module.exports = require('./format-quantity.cjs.development.js');
+}

package/dist/format-quantity.d.ts

@@ -0,0 +1,83 @@
+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 alue must be between 1 and 3999.
+     * Decimal values will be ignored.
+     */
+    romanNumerals?: boolean;
+}
+type FormatQuantity = (qty: string | number, options?: boolean | FormatQuantityOptions) => string | null;
+type NonZeroNumChar = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type NumChar = '0' | NonZeroNumChar;
+type SimpleFraction = `${NonZeroNumChar}/${NonZeroNumChar}` | `${NonZeroNumChar}/${NonZeroNumChar}${NumChar}` | `${NonZeroNumChar}${NumChar}/${NonZeroNumChar}${NumChar}`;
+type Sixteenth = `${'1' | '3' | '5' | '7' | '9' | '11' | '13' | '15'}/16`;
+type VulgarFraction = '¼' | '½' | '¾' | '⅐' | '⅑' | '⅒' | '⅓' | '⅔' | '⅕' | '⅖' | '⅗' | '⅘' | '⅙' | '⅚' | '⅛' | '⅜' | '⅝' | '⅞';
+type FormatQuantityTests = Record<string, ([Parameters<FormatQuantity>[0], ReturnType<FormatQuantity>] | [
+    Parameters<FormatQuantity>[0],
+    ReturnType<FormatQuantity>,
+    Parameters<FormatQuantity>[1]
+])[]>;
+
+/**
+ * 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 the [documentation](https://jakeboone02.github.io/format-quantity/).
+ */
+declare const formatQuantity: FormatQuantity;
+
+declare const defaultTolerance: 0.0075;
+declare const defaultOptions: {
+    vulgarFractions: false;
+    tolerance: 0.0075;
+    fractionSlash: false;
+    romanNumerals: false;
+};
+/**
+ * A map of vulgar or simple sixteenth fractions to their traditional ASCII
+ * equivalents. Sixteenths map to themselves.
+ */
+declare const vulgarToAsciiMap: {
+    '\u00BC': "1/4";
+    '\u00BD': "1/2";
+    '\u00BE': "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";
+};
+declare const fractionDecimalMatches: ([number, "⅓"] | [number, "⅔"] | [number, "⅕"] | [number, "⅖"] | [number, "⅗"] | [number, "⅘"] | [number, "⅙"] | [number, "⅚"] | [number, "⅐"] | [number, "⅑"] | [number, "⅒"] | [number, "⅛"] | [number, "¼"] | [number, "⅜"] | [number, "½"] | [number, "⅝"] | [number, "¾"] | [number, "⅞"] | [number, "1/16"] | [number, "3/16"] | [number, "5/16"] | [number, "7/16"] | [number, "9/16"] | [number, "11/16"] | [number, "13/16"] | [number, "15/16"])[];
+
+export { FormatQuantity, FormatQuantityOptions, FormatQuantityTests, SimpleFraction, Sixteenth, VulgarFraction, formatQuantity as default, defaultOptions, defaultTolerance, formatQuantity, fractionDecimalMatches, vulgarToAsciiMap };