shelving 1.89.5 → 1.90.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.89.5",
+	"version": "1.90.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/state/DataState.d.ts

@@ -1,21 +1,33 @@
-import { Data, OptionalData } from "../util/data.js";
-import { Transformers } from "../util/transform.js";
+import { Data, DataKey } from "../util/data.js";
+import { Transformers, Transformer } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export declare class DataState<T extends Data> extends State<T> {
     /** Get the data value of this state. */
     get data(): T;
+    /** Update a single named prop in this data. */
+    getProp<K extends DataKey<T>>(name: K): T[K];
+    /** Update a single named prop in this data. */
+    setProp<K extends DataKey<T>>(name: K, value: T[K]): void;
+    /** Update a single named prop in this data. */
+    updateProp<K extends DataKey<T>>(name: K, update: Transformer<T[K], T[K]>): void;
     /** Update several props in this data. */
     update(updates: Transformers<T>): void;
 }
 /** State that stores an optional data object and has additional methods to help with that. */
-export declare class OptionalDataState<T extends Data> extends State<OptionalData<T>> {
+export declare class OptionalDataState<T extends Data> extends State<T | null> {
     /** Get current data value of this state (or throw `Promise` that resolves to the next required value). */
     get data(): T;
     /** Does the data exist or not? */
     get exists(): boolean;
     /** Update several props in this data. */
     update(updates: Transformers<T>): void;
+    /** Update a single named prop in this data. */
+    getProp<K extends DataKey<T>>(name: K): T[K];
+    /** Update a single named prop in this data. */
+    setProp<K extends DataKey<T>>(name: K, value: T[K]): void;
+    /** Update a single named prop in this data. */
+    updateProp<K extends DataKey<T>>(name: K, update: Transformer<T[K], T[K]>): void;
     /** Set the data to `null`. */
     unset(): void;
 }

package/state/DataState.js

@@ -1,5 +1,6 @@
+import { withProp } from "../util/object.js";
 import { getData } from "../util/data.js";
-import { transformObject } from "../util/transform.js";
+import { transform, transformObject } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export class DataState extends State {
@@ -7,6 +8,19 @@ export class DataState extends State {
     get data() {
         return this.value;
     }
+    /** Update a single named prop in this data. */
+    getProp(name) {
+        return this.data[name];
+    }
+    /** Update a single named prop in this data. */
+    setProp(name, value) {
+        this.set(withProp(this.data, name, value));
+    }
+    /** Update a single named prop in this data. */
+    updateProp(name, update) {
+        const data = this.data;
+        this.set(withProp(data, name, transform(data[name], update)));
+    }
     /** Update several props in this data. */
     update(updates) {
         this.set(transformObject(this.data, updates));
@@ -26,6 +40,19 @@ export class OptionalDataState extends State {
     update(updates) {
         this.set(transformObject(this.data, updates));
     }
+    /** Update a single named prop in this data. */
+    getProp(name) {
+        return this.data[name];
+    }
+    /** Update a single named prop in this data. */
+    setProp(name, value) {
+        this.set(withProp(this.data, name, value));
+    }
+    /** Update a single named prop in this data. */
+    updateProp(name, update) {
+        const data = this.data;
+        this.set(withProp(data, name, transform(data[name], update)));
+    }
     /** Set the data to `null`. */
     unset() {
         this.set(null);

package/state/DictionaryState.d.ts

@@ -1,5 +1,5 @@
 import { DictionaryItem, ImmutableDictionary } from "../util/dictionary.js";
-import { Transformers } from "../util/transform.js";
+import { Transformer, Transformers } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a dictionary object and has additional methods to help with that. */
 export declare class DictionaryState<T> extends State<ImmutableDictionary<T>> implements Iterable<DictionaryItem<T>> {
@@ -10,6 +10,12 @@ export declare class DictionaryState<T> extends State<ImmutableDictionary<T>> im
     update(updates: Transformers<ImmutableDictionary<T>>): void;
     /** Remove a named entry from this object. */
     delete(...keys: string[]): void;
+    /** Update a single named prop in this data. */
+    getItem(name: string): T | undefined;
+    /** Update a single named prop in this data. */
+    setItem(name: string, value: T): void;
+    /** Update a single named prop in this data. */
+    updateItem(name: string, update: Transformer<T | undefined, T>): void;
     /** Iterate over the entries of the object. */
     [Symbol.iterator](): Iterator<DictionaryItem<T>>;
 }

package/state/DictionaryState.js

@@ -1,5 +1,6 @@
+import { withProp } from "../util/object.js";
 import { omitDictionaryItems } from "../util/dictionary.js";
-import { transformDictionary } from "../util/transform.js";
+import { transform, transformDictionary } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a dictionary object and has additional methods to help with that. */
 export class DictionaryState extends State {
@@ -18,6 +19,19 @@ export class DictionaryState extends State {
     delete(...keys) {
         this.set(omitDictionaryItems(this.value, ...keys));
     }
+    /** Update a single named prop in this data. */
+    getItem(name) {
+        return this.value[name];
+    }
+    /** Update a single named prop in this data. */
+    setItem(name, value) {
+        this.set(withProp(this.value, name, value));
+    }
+    /** Update a single named prop in this data. */
+    updateItem(name, update) {
+        const value = this.value;
+        this.set(withProp(value, name, transform(value[name], update)));
+    }
     /** Iterate over the entries of the object. */
     [Symbol.iterator]() {
         return Object.entries(this.value)[Symbol.iterator]();

package/util/duration.d.ts

@@ -1,17 +1,17 @@
 import { PossibleDate } from "./date.js";
 /** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export declare function formatFullDuration(ms: number): string;
+export declare function pluralizeDuration(ms: number): string;
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
 export declare function formatDuration(ms: number): string;
 /** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export declare const formatFullWhen: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeWhen: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
 export declare const formatWhen: (target: PossibleDate, current?: PossibleDate) => string;
 /** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const formatFullUntil: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeUntil: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
 export declare const formatUntil: (target: PossibleDate, current?: PossibleDate) => string;
 /** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export declare const formatFullAgo: (target: PossibleDate, current?: PossibleDate) => string;
+export declare const pluralizeAgo: (target: PossibleDate, current?: PossibleDate) => string;
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
 export declare const formatAgo: (target: PossibleDate, current?: PossibleDate) => string;

package/util/duration.js

@@ -20,15 +20,17 @@ function _getTimeUnit(ms) {
         return TIME_UNITS.unit("second");
     return TIME_UNITS.unit("millisecond");
 }
+/** Default number options for duration (no decimal places and rounding down). */
+const NUMBER_OPTIONS = { maximumFractionDigits: 0, roundingMode: "trunc" };
 /** Format a full format of a duration of time using the most reasonable units e.g. `5 years` or `1 week` or `4 minutes` or `12 milliseconds`. */
-export function formatFullDuration(ms) {
+export function pluralizeDuration(ms) {
     const unit = _getTimeUnit(ms);
-    return unit.formatFull(unit.from(ms), 0);
+    return unit.pluralize(unit.from(ms), NUMBER_OPTIONS);
 }
 /** Format a description of a duration of time using the most reasonable units e.g. `5y` or `4m` or `12ms`. */
 export function formatDuration(ms) {
     const unit = _getTimeUnit(ms);
-    return unit.format(unit.from(ms), 0);
+    return unit.format(unit.from(ms), NUMBER_OPTIONS);
 }
 /** format when a data happens/happened. */
 function _formatWhen(formatter, target, current) {
@@ -38,14 +40,14 @@ function _formatWhen(formatter, target, current) {
     return abs < 10 * SECOND ? "just now" : ms > 0 ? `in ${duration}` : `${duration} ago`;
 }
 /** Full when a date happens/happened, e.g. `in 10 days` or `2 hours ago` */
-export const formatFullWhen = (target, current) => _formatWhen(formatFullDuration, target, current);
+export const pluralizeWhen = (target, current) => _formatWhen(pluralizeDuration, target, current);
 /** Compact when a date happens/happened, e.g. `in 10d` or `2h ago` or `in 1w` */
 export const formatWhen = (target, current) => _formatWhen(formatDuration, target, current);
 /** Full when a date happens, e.g. `10 days` or `2 hours` or `-1 week` */
-export const formatFullUntil = (target, current) => formatFullDuration(getDuration(target, current));
+export const pluralizeUntil = (target, current) => pluralizeDuration(getDuration(target, current));
 /** Compact when a date happens, e.g. `10d` or `2h` or `-1w` */
 export const formatUntil = (target, current) => formatDuration(getDuration(target, current));
 /** Full when a date happened, e.g. `10 days` or `2 hours` or `-1 week` */
-export const formatFullAgo = (target, current) => formatFullDuration(getDuration(current, target));
+export const pluralizeAgo = (target, current) => pluralizeDuration(getDuration(current, target));
 /** Compact when a date will happen, e.g. `10d` or `2h` or `-1w` */
 export const formatAgo = (target, current) => formatDuration(getDuration(current, target));

package/util/number.d.ts

@@ -59,8 +59,7 @@ export declare const roundNumber: (num: number, precision?: number) => number;
  * - Better than `Math.trunc()` because it allows a `precision` argument.
  *
  * @param num The number to truncate.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10).
- *
+ * @param precision Maximum number of digits shown after the decimal point (defaults to 0).
  * @returns The number truncated to the specified precision.
  */
 export declare const truncateNumber: (num: number, precision?: number) => number;
@@ -68,51 +67,35 @@ export declare const truncateNumber: (num: number, precision?: number) => number
 export declare function boundNumber(num: number, min: number, max: number): number;
 /** Wrap a number so it fits between two values. */
 export declare function wrapNumber(num: number, min: number, max: number): number;
+/** Options for `formatNumber()` and `formatRange()`. */
+export interface NumberOptions extends Intl.NumberFormatOptions {
+    roundingMode?: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven" | undefined;
+    roundingPriority?: "morePrecision" | "lessPrecision" | undefined;
+}
 /** Format a number (based on the user's browser language settings). */
-export declare function formatNumber(num: number, precision?: number | null): string;
+export declare function formatNumber(num: number, options?: NumberOptions): string;
 /** Format a number range (based on the user's browser language settings). */
-export declare function formatRange(min: number, max: number, precision?: number | null): string;
+export declare function formatRange(min: number, max: number, options?: NumberOptions): string;
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export declare const formatQuantity: (num: number, abbr: string, precision?: number | null) => string;
+export declare const formatQuantity: (num: number, abbr: string, options?: NumberOptions) => string;
 /** Format a number with a longer full-word suffix. */
-export declare function formatFullQuantity(num: number, singular: string, plural: string, precision?: number | null): string;
+export declare function pluralizeQuantity(num: number, singular: string, plural: string, options?: NumberOptions): string;
 /**
- * Cram a large whole numbers into a space efficient format, e.g. `14.7M`
- * - Improves glanceability.
- * - Keeps number of characters under five if possible.
- *
- * - Numbers over 100 trillion: `157T`
- * - Numbers over 10 trillion: `15.7T` (includes zero e.g. `40.0T` for consistency).
- * - Numbers over 1 trillion: `1.57T` (includes zeros e.g. `4.00T` for consistency).
- * - Numbers over 100 billion: `157B`
- * - Numbers over 10 billion: `15.7B` (includes zero e.g. `40.0B` for consistency).
- * - Numbers over 1 billion: `1.57B` (includes zeros e.g. `4.00B` for consistency).
- * - Numbers over 100 million: `157M`
- * - Numbers over 10 million: `15.7M` (includes zero e.g. `40.0M` for consistency).
- * - Numbers over 1 million: `1.57M` (includes zeros e.g. `4.00M` for consistency).
- * - Numbers over 100,000: `157K`
- * - Numbers over 10,000: `15.7K` (includes zero e.g. `14.0K` for consistency).
- * - Smaller numbers: `1570` and `157` and `15.7` and `1.6`
- *
- * @param num The number to format.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10, only used for numbers under 10,000).
+ * Get a number as a percentage of another number.
  *
- * @returns The number formatted as a crammed string.
+ * @param numerator Number representing the amount of progress.
+ * @param denumerator The number representing the whole amount.
  */
-export declare function cramNumber(num: number): string;
-/** Cram a number with a short suffix, e.g. `1.02M kg` */
-export declare const cramQuantity: (num: number, suffix: string) => string;
-/** Cram a number with a longer full-word suffix. */
-export declare function cramFullQuantity(num: number, singular: string, plural: string): string;
+export declare const getPercent: (numerator: number, denumerator: number) => number;
 /**
- * Get a number as a percentage of another number.
+ * Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience).
+ * - Defaults to showing no decimal places.
+ * - Defaults to rounding closer to zero (so that 99.99% is shown as 99%).
  *
  * @param numerator Number representing the amount of progress.
  * @param denumerator The number representing the whole amount.
  */
-export declare const getPercent: (numerator: number, denumerator: number) => number;
-/** Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience). */
-export declare const formatPercent: (numerator: number, denumerator: number, precision?: number) => string;
+export declare const formatPercent: (numerator: number, denumerator: number, options?: NumberOptions) => string;
 /** Sum an iterable set of numbers and return the total. */
 export declare function sumNumbers(nums: Iterable<number>): number;
 /** Find the number that's closest to a target in an iterable set of numbers. */

package/util/number.js

@@ -1,5 +1,5 @@
 import { AssertionError } from "../error/AssertionError.js";
-import { BILLION, MILLION, NNBSP, TEN_THOUSAND, THOUSAND, TRILLION } from "./constants.js";
+import { NNBSP } from "./constants.js";
 /** Is a value a number? */
 export const isNumber = (value) => typeof value === "number";
 /** Assert that a value is a number. */
@@ -89,8 +89,7 @@ export const roundNumber = (num, precision = 0) => Math.round(num * 10 ** precis
  * - Better than `Math.trunc()` because it allows a `precision` argument.
  *
  * @param num The number to truncate.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10).
- *
+ * @param precision Maximum number of digits shown after the decimal point (defaults to 0).
  * @returns The number truncated to the specified precision.
  */
 export const truncateNumber = (num, precision = 0) => Math.trunc(num * 10 ** precision) / 10 ** precision;
@@ -109,79 +108,40 @@ export function wrapNumber(num, min, max) {
     return num;
 }
 /** Format a number (based on the user's browser language settings). */
-export function formatNumber(num, precision = null) {
+export function formatNumber(num, options = { maximumFractionDigits: 2 }) {
     if (Number.isNaN(num))
         return "None";
     if (!Number.isFinite(num))
         return "∞";
-    return new Intl.NumberFormat(undefined, { minimumFractionDigits: precision !== null && precision !== void 0 ? precision : undefined, maximumFractionDigits: precision !== null && precision !== void 0 ? precision : 20 }).format(num);
+    return new Intl.NumberFormat(undefined, options).format(num);
 }
 /** Format a number range (based on the user's browser language settings). */
-export function formatRange(min, max, precision = null) {
-    return `${formatNumber(min, precision)}–${formatNumber(max, precision)}`;
+export function formatRange(min, max, options) {
+    return `${formatNumber(min, options)}–${formatNumber(max, options)}`;
 }
 /** Format a number with a short suffix, e.g. `1,000 kg` */
-export const formatQuantity = (num, abbr, precision) => `${formatNumber(num, precision)}${NNBSP}${abbr}`;
+export const formatQuantity = (num, abbr, options) => `${formatNumber(num, options)}${NNBSP}${abbr}`;
 /** Format a number with a longer full-word suffix. */
-export function formatFullQuantity(num, singular, plural, precision) {
-    const qty = formatNumber(num, precision);
+export function pluralizeQuantity(num, singular, plural, options) {
+    const qty = formatNumber(num, options);
     return `${qty} ${qty === "1" ? singular : plural}`;
 }
 /**
- * Cram a large whole numbers into a space efficient format, e.g. `14.7M`
- * - Improves glanceability.
- * - Keeps number of characters under five if possible.
- *
- * - Numbers over 100 trillion: `157T`
- * - Numbers over 10 trillion: `15.7T` (includes zero e.g. `40.0T` for consistency).
- * - Numbers over 1 trillion: `1.57T` (includes zeros e.g. `4.00T` for consistency).
- * - Numbers over 100 billion: `157B`
- * - Numbers over 10 billion: `15.7B` (includes zero e.g. `40.0B` for consistency).
- * - Numbers over 1 billion: `1.57B` (includes zeros e.g. `4.00B` for consistency).
- * - Numbers over 100 million: `157M`
- * - Numbers over 10 million: `15.7M` (includes zero e.g. `40.0M` for consistency).
- * - Numbers over 1 million: `1.57M` (includes zeros e.g. `4.00M` for consistency).
- * - Numbers over 100,000: `157K`
- * - Numbers over 10,000: `15.7K` (includes zero e.g. `14.0K` for consistency).
- * - Smaller numbers: `1570` and `157` and `15.7` and `1.6`
- *
- * @param num The number to format.
- * @param precision Maximum number of digits shown after the decimal point (defaults to 10, only used for numbers under 10,000).
+ * Get a number as a percentage of another number.
  *
- * @returns The number formatted as a crammed string.
+ * @param numerator Number representing the amount of progress.
+ * @param denumerator The number representing the whole amount.
  */
-export function cramNumber(num) {
-    const abs = Math.abs(num);
-    if (abs >= TRILLION)
-        return `${_significance(num / TRILLION)}T`;
-    if (abs >= BILLION)
-        return `${_significance(num / BILLION)}B`;
-    if (abs >= MILLION)
-        return `${_significance(num / MILLION)}M`;
-    if (abs >= TEN_THOUSAND)
-        return `${_significance(num / THOUSAND)}K`;
-    return truncateNumber(num, 2).toString();
-}
-function _significance(num) {
-    const digits = num >= 100 ? 0 : num >= 10 ? 1 : 2;
-    return truncateNumber(num, digits).toFixed(digits);
-}
-/** Cram a number with a short suffix, e.g. `1.02M kg` */
-export const cramQuantity = (num, suffix) => `${cramNumber(num)}${NNBSP}${suffix}`;
-/** Cram a number with a longer full-word suffix. */
-export function cramFullQuantity(num, singular, plural) {
-    const qty = cramNumber(num);
-    return `${qty} ${qty === "1" ? singular : plural}`;
-}
+export const getPercent = (numerator, denumerator) => Math.max(0, Math.min(100, (100 / denumerator) * numerator));
 /**
- * Get a number as a percentage of another number.
+ * Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience).
+ * - Defaults to showing no decimal places.
+ * - Defaults to rounding closer to zero (so that 99.99% is shown as 99%).
  *
  * @param numerator Number representing the amount of progress.
  * @param denumerator The number representing the whole amount.
  */
-export const getPercent = (numerator, denumerator) => Math.max(0, Math.min(100, (100 / denumerator) * numerator));
-/** Format a percentage (combines `getPercent()` and `formatQuantity()` for convenience). */
-export const formatPercent = (numerator, denumerator, precision) => formatQuantity(getPercent(numerator, denumerator), "%", precision);
+export const formatPercent = (numerator, denumerator, options) => formatQuantity(getPercent(numerator, denumerator), "%", { maximumFractionDigits: 0, roundingMode: "trunc", ...options });
 /** Sum an iterable set of numbers and return the total. */
 export function sumNumbers(nums) {
     let sum = 0;

package/util/units.d.ts

@@ -1,12 +1,12 @@
 import { ImmutableObject } from "./object.js";
 import { MapKey, ImmutableMap } from "./map.js";
+import { NumberOptions } from "./number.js";
 /** Conversion from one unit to another (either an amount to multiple by, or a function to convert). */
 type Conversion = number | ((num: number) => number);
 /** Set of possible conversions for a set of items. */
 type Conversions<T extends string> = {
     readonly [K in T]?: Conversion;
 };
-/** Get a `Unit` instance from a `UnitList` instance */
 type UnitProps<T extends string> = {
     /** Short abbreviation for this unit, e.g. `km` (defaults to first letter of `id`). */
     readonly abbr?: string;
@@ -14,8 +14,6 @@ type UnitProps<T extends string> = {
     readonly singular?: string;
     /** Plural name for this unit, e.g. `kilometers` (defaults to `id`). */
     readonly plural?: string;
-    /** Default precision for this unit (defaults to `null`). */
-    readonly precision?: number | null;
     /** Conversions to other units (typically needs at least the base conversion, unless it's already the base unit). */
     readonly to?: Conversions<T>;
 };
@@ -32,8 +30,6 @@ export declare class Unit<K extends string> {
     readonly singular: string;
     /** Plural name for this unit, e.g. `kilometers` (defaults to `singular` + "s"). */
     readonly plural: string;
-    /** Default precision for this unit (defaults to `null`). */
-    readonly precision: number | null;
     /** Title for this unit (uses format `abbr (plural)`, e.g. `fl oz (US fluid ounces)`) */
     get title(): string;
     constructor(
@@ -42,7 +38,7 @@ export declare class Unit<K extends string> {
     /** String key for this unit, e.g. `kilometer` */
     key: K, 
     /** Props to configure this unit. */
-    { abbr, singular, plural, precision, to }: UnitProps<K>);
+    { abbr, singular, plural, to }: UnitProps<K>);
     /** Convert an amount from this unit to another unit. */
     to(amount: number, unit?: K | Unit<K>): number;
     /** Convert an amount from another unit to this unit. */
@@ -50,11 +46,9 @@ export declare class Unit<K extends string> {
     /** Convert an amount from this unit to another unit (must specify another `Unit` instance). */
     private _toUnit;
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
-    format(amount: number, precision?: number | null): string;
+    format(amount: number, options?: NumberOptions): string;
     /** Format an amount with a given unit of measure, e.g. `12 kilograms` or `29.5 liters` or `1 degree` */
-    formatFull(amount: number, precision?: number | null): string;
-    /** Cram an amount with a given unit of measure, e.g. `1.25M mi` */
-    cram(amount: number): string;
+    pluralize(amount: number, options?: NumberOptions): string;
 }
 /**
  * Represent a list of units.

package/util/units.js

@@ -3,7 +3,7 @@ import { RequiredError } from "../error/RequiredError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
 import { getProps } from "./object.js";
 import { ImmutableMap } from "./map.js";
-import { cramQuantity, formatFullQuantity, formatQuantity } from "./number.js";
+import { pluralizeQuantity, formatQuantity } from "./number.js";
 /** Convert an amount using a `Conversion. */
 const _convert = (amount, conversion) => (typeof conversion === "function" ? conversion(amount) : conversion === 1 ? amount : amount * conversion);
 /** Represent a unit. */
@@ -18,13 +18,12 @@ export class Unit {
     /** String key for this unit, e.g. `kilometer` */
     key, 
     /** Props to configure this unit. */
-    { abbr = key.slice(0, 1), singular = key.replace(/-/, " "), plural = `${singular}s`, precision = null, to }) {
+    { abbr = key.slice(0, 1), singular = key.replace(/-/, " "), plural = `${singular}s`, to }) {
         this.list = list;
         this.key = key;
         this.abbr = abbr;
         this.singular = singular;
         this.plural = plural;
-        this.precision = precision;
         this._to = to;
     }
     /** Convert an amount from this unit to another unit. */
@@ -58,16 +57,12 @@ export class Unit {
         throw new ConditionError(`Cannot convert "${this.key}" to "${unit.key}"`);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
-    format(amount, precision = this.precision) {
-        return formatQuantity(amount, this.abbr, precision);
+    format(amount, options) {
+        return formatQuantity(amount, this.abbr, options);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kilograms` or `29.5 liters` or `1 degree` */
-    formatFull(amount, precision = this.precision) {
-        return formatFullQuantity(amount, this.singular, this.plural, precision);
-    }
-    /** Cram an amount with a given unit of measure, e.g. `1.25M mi` */
-    cram(amount) {
-        return cramQuantity(amount, this.abbr);
+    pluralize(amount, options) {
+        return pluralizeQuantity(amount, this.singular, this.plural, options);
     }
 }
 /**