@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/navigation-tree/index.jsx

@@ -0,0 +1,110 @@
+// Ported from react-aria-components (src/NavigationTree.tsx), Apache-2.0, © Adobe.
+// Rivet:
+// - NavigationTree / NavigationTreeItem / NavigationTreeItemContent / NavigationTreeSection /
+//   NavigationTreeHeader over `../tree` (Tree with selectionMode "none", keyboardNavigationBehavior "tab";
+//   items: focusMode "child" when linked, allowsArrowNavigation).
+// - RAC NavigationTreeItem wraps TreeItem's `render` prop to add `data-current` / `data-current-ancestor`,
+//   the link-driven `data-focus-visible` and contexts around the row children. Rivet's TreeItem applies them
+//   itself (no `render` wrapper) when an enclosing NavigationTree provides
+//   `InternalNavigationTreeContext` (`../tree/navigation-context.tsx`).
+// - `selectedRoute` is a value or an accessor / Signal (a re-render in React).
+// - Render props are accessors (`isCurrent()`, `isCurrentAncestor()`); default classes `rv-NavigationTree*`.
+// - useRouteFocusSync: a `clientEffect` in NavigationTreeItemContent (React `useEffect`).
+// `render` (RAC DOMRenderProps): NavigationTree* parts pass `render` through to Tree / TreeItem / TreeSection / TreeHeader (which support it).
+import { createContext, untrack, useContext } from "@rivetjs/reactivity";
+import { clientEffect } from "@rivetjs/runtime/dom";
+import { toggleTreeKey, treeCollection, treeSelectionManager } from "../collections/tree-state.js";
+import { LinkContext } from "../link/index.jsx";
+import { Provider, contextProps, renderProps, resumableContext, } from "../slots/index.jsx";
+import { Tree, TreeHeader, TreeItem, TreeItemContent, TreeSection, } from "../tree/index.jsx";
+import { InternalNavigationTreeContext, NavigationTreeItemLinkContext, NavigationTreeItemStateContext, closestVisibleKey, findKeyForRoute, } from "../tree/navigation-context.jsx";
+export { NavigationTreeItemStateContext };
+/** RAC `NavigationTreeContext`: props for the NavigationTrees inside a component. */
+export const NavigationTreeContext = resumableContext(createContext(null, { id: "rv-navigation-tree-props" }));
+/** A NavigationTree provides users with a way to navigate a nested, hierarchical set of links. */
+export function NavigationTree(inProps) {
+    const [props, ref] = contextProps(inProps, inProps.ref, NavigationTreeContext);
+    const { class: className, style, children, selectedRoute, ref: _ownRef, ...rest } = props;
+    const context = {
+        selectedRoute: () => (typeof selectedRoute === "function" ? selectedRoute() : selectedRoute),
+        syncedRoute: { current: undefined },
+    };
+    return (<Provider values={[[InternalNavigationTreeContext, context]]}>
+      <Tree {...rest} ref={ref} class={(className ?? "rv-NavigationTree")} style={style} selectionMode="none" keyboardNavigationBehavior="tab">
+        {children}
+      </Tree>
+    </Provider>);
+}
+/** A NavigationTreeItem represents an individual item in a NavigationTree. */
+export function NavigationTreeItem(props) {
+    const { class: className, style, focusMode, children, ...rest } = props;
+    const hasLink = rest.href != null && rest.href.length > 0;
+    return (<TreeItem {...rest} focusMode={focusMode ?? (hasLink ? "child" : undefined)} allowsArrowNavigation class={(className ?? "rv-NavigationTreeItem")} style={style}>
+      {children}
+    </TreeItem>);
+}
+/** The content of a NavigationTreeItem: its `Link` gets the item's href, `aria-current` and focus tracking. */
+export function NavigationTreeItemContent(props) {
+    const children = props.children;
+    return (<TreeItemContent>
+      {(values) => <NavigationTreeItemContentInner values={values}>{children}</NavigationTreeItemContentInner>}
+    </TreeItemContent>);
+}
+function NavigationTreeItemContentInner(props) {
+    const values = props.values;
+    const children = props.children;
+    const link = useContext(NavigationTreeItemLinkContext);
+    const nav = useContext(InternalNavigationTreeContext);
+    const state = values.state;
+    const id = values.id;
+    // useRouteFocusSync: move the tree's focused key to the item matching selectedRoute (once per change,
+    // deduped across items).
+    clientEffect(() => {
+        const route = nav?.selectedRoute();
+        if (route == null || !nav || nav.syncedRoute.current === route)
+            return;
+        const collection = treeCollection(state);
+        let key = findKeyForRoute(collection, route);
+        if (key != null) {
+            key = closestVisibleKey(collection, state.expandedKeys(), key);
+            nav.syncedRoute.current = route;
+            untrack(() => treeSelectionManager(state, collection).setFocusedKey(key));
+        }
+    });
+    const href = link?.href;
+    const isCurrent = link?.isCurrent;
+    const isLinkFocused = link?.isLinkFocused;
+    // RAC: a parent row's Link without href expands / collapses the row. The arrow lives in an object literal (a
+    // resumable closure) and is picked by reference: a bare `c ? () => … : undefined` branch is not resumable.
+    const toggle = { onPress: () => toggleTreeKey(state, id) };
+    const togglesRow = href == null && untrack(values.hasChildItems);
+    const linkContextValue = {
+        href,
+        hrefLang: link?.hrefLang,
+        target: link?.target,
+        rel: link?.rel,
+        download: link?.download,
+        ping: link?.ping,
+        referrerPolicy: link?.referrerPolicy,
+        routerOptions: link?.routerOptions,
+        "aria-current": () => (isCurrent?.() ? "page" : undefined),
+        onFocusChange: (isFocused) => isLinkFocused?.set(isFocused),
+        onPress: togglesRow ? toggle.onPress : undefined,
+    };
+    const rp = renderProps({ children: children, values });
+    return <Provider values={[[LinkContext, linkContextValue]]}>{rp.children()}</Provider>;
+}
+/** A NavigationTreeSection represents a section within a NavigationTree. */
+export function NavigationTreeSection(props) {
+    const { children, ...rest } = props;
+    return (<TreeSection class="rv-NavigationTreeSection" {...rest}>
+      {children}
+    </TreeSection>);
+}
+/** A NavigationTreeHeader renders the header of a NavigationTreeSection. */
+export function NavigationTreeHeader(props) {
+    const { children, ...rest } = props;
+    return (<TreeHeader class="rv-NavigationTreeHeader" {...rest}>
+      {children}
+    </TreeHeader>);
+}

package/number/NumberFormatter.d.ts

@@ -0,0 +1,28 @@
+export interface NumberFormatOptions extends Intl.NumberFormatOptions {
+    /** Overrides default numbering system for the current locale. */
+    numberingSystem?: string;
+}
+/**
+ * A wrapper around Intl.NumberFormat providing additional options, polyfills, and caching for
+ * performance.
+ */
+export declare class NumberFormatter implements Intl.NumberFormat {
+    private numberFormatter;
+    private options;
+    constructor(locale: string, options?: NumberFormatOptions);
+    /**
+     * Formats a number value as a string, according to the locale and options provided to the
+     * constructor.
+     */
+    format(value: number): string;
+    /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+    formatToParts(value: number): Intl.NumberFormatPart[];
+    /** Formats a number range as a string. */
+    formatRange(start: number, end: number): string;
+    /** Formats a number range as an array of parts. */
+    formatRangeToParts(start: number, end: number): Intl.NumberRangeFormatPart[];
+    /** Returns the resolved formatting options based on the values passed to the constructor. */
+    resolvedOptions(): Intl.ResolvedNumberFormatOptions;
+}
+/** @private - Exported for tests */
+export declare function numberFormatSignDisplayPolyfill(numberFormat: Intl.NumberFormat, signDisplay: string, num: number): string;

package/number/NumberFormatter.js

@@ -0,0 +1,144 @@
+// Ported from @internationalized/number src/NumberFormatter.ts (react-spectrum, v3.6.8), Apache-2.0, © Adobe.
+// Changes: formatting only (repo prettier). No behaviour changes.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+let formatterCache = new Map();
+let supportsSignDisplay = false;
+try {
+    supportsSignDisplay = new Intl.NumberFormat("de-DE", { signDisplay: "exceptZero" }).resolvedOptions().signDisplay === "exceptZero";
+    // eslint-disable-next-line no-empty
+}
+catch { }
+/**
+ * A wrapper around Intl.NumberFormat providing additional options, polyfills, and caching for
+ * performance.
+ */
+export class NumberFormatter {
+    numberFormatter;
+    options;
+    constructor(locale, options = {}) {
+        this.numberFormatter = getCachedNumberFormatter(locale, options);
+        this.options = options;
+    }
+    /**
+     * Formats a number value as a string, according to the locale and options provided to the
+     * constructor.
+     */
+    format(value) {
+        let res = "";
+        if (!supportsSignDisplay && this.options.signDisplay != null) {
+            res = numberFormatSignDisplayPolyfill(this.numberFormatter, this.options.signDisplay, value);
+        }
+        else {
+            res = this.numberFormatter.format(value);
+        }
+        return res;
+    }
+    /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+    formatToParts(value) {
+        // TODO: implement signDisplay for formatToParts
+        return this.numberFormatter.formatToParts(value);
+    }
+    /** Formats a number range as a string. */
+    formatRange(start, end) {
+        if (typeof this.numberFormatter.formatRange === "function") {
+            return this.numberFormatter.formatRange(start, end);
+        }
+        if (end < start) {
+            throw new RangeError("End date must be >= start date");
+        }
+        // Very basic fallback for old browsers.
+        return `${this.format(start)} – ${this.format(end)}`;
+    }
+    /** Formats a number range as an array of parts. */
+    formatRangeToParts(start, end) {
+        if (typeof this.numberFormatter.formatRangeToParts === "function") {
+            return this.numberFormatter.formatRangeToParts(start, end);
+        }
+        if (end < start) {
+            throw new RangeError("End date must be >= start date");
+        }
+        let startParts = this.numberFormatter.formatToParts(start);
+        let endParts = this.numberFormatter.formatToParts(end);
+        return [
+            ...startParts.map((p) => ({ ...p, source: "startRange" })),
+            { type: "literal", value: " – ", source: "shared" },
+            ...endParts.map((p) => ({ ...p, source: "endRange" })),
+        ];
+    }
+    /** Returns the resolved formatting options based on the values passed to the constructor. */
+    resolvedOptions() {
+        let options = this.numberFormatter.resolvedOptions();
+        if (!supportsSignDisplay && this.options.signDisplay != null) {
+            options = { ...options, signDisplay: this.options.signDisplay };
+        }
+        return options;
+    }
+}
+function getCachedNumberFormatter(locale, options = {}) {
+    let { numberingSystem } = options;
+    if (numberingSystem && locale.includes("-nu-")) {
+        if (!locale.includes("-u-")) {
+            locale += "-u-";
+        }
+        locale += `-nu-${numberingSystem}`;
+    }
+    let cacheKey = locale +
+        (options
+            ? Object.entries(options)
+                .sort((a, b) => (a[0] < b[0] ? -1 : 1))
+                .join()
+            : "");
+    if (formatterCache.has(cacheKey)) {
+        return formatterCache.get(cacheKey);
+    }
+    let numberFormatter = new Intl.NumberFormat(locale, options);
+    formatterCache.set(cacheKey, numberFormatter);
+    return numberFormatter;
+}
+/** @private - Exported for tests */
+export function numberFormatSignDisplayPolyfill(numberFormat, signDisplay, num) {
+    if (signDisplay === "auto") {
+        return numberFormat.format(num);
+    }
+    else if (signDisplay === "never") {
+        return numberFormat.format(Math.abs(num));
+    }
+    else {
+        let needsPositiveSign = false;
+        if (signDisplay === "always") {
+            needsPositiveSign = num > 0 || Object.is(num, 0);
+        }
+        else if (signDisplay === "exceptZero") {
+            if (Object.is(num, -0) || Object.is(num, 0)) {
+                num = Math.abs(num);
+            }
+            else {
+                needsPositiveSign = num > 0;
+            }
+        }
+        if (needsPositiveSign) {
+            let negative = numberFormat.format(-num);
+            let noSign = numberFormat.format(num);
+            // ignore RTL/LTR marker character
+            let minus = negative.replace(noSign, "").replace(/\u200e|\u061C/, "");
+            if ([...minus].length !== 1) {
+                console.warn("@react-aria/i18n polyfill for NumberFormat signDisplay: Unsupported case");
+            }
+            let positive = negative.replace(noSign, "!!!").replace(minus, "+").replace("!!!", noSign);
+            return positive;
+        }
+        else {
+            return numberFormat.format(num);
+        }
+    }
+}

package/number/NumberParser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A NumberParser can be used to perform locale-aware parsing of numbers from Unicode strings,
+ * as well as validation of partial user input. It automatically detects the numbering system
+ * used in the input, and supports parsing decimals, percentages, currency values, and units
+ * according to the locale.
+ */
+export declare class NumberParser {
+    private locale;
+    private options;
+    constructor(locale: string, options?: Intl.NumberFormatOptions);
+    /**
+     * Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+     */
+    parse(value: string): number;
+    /**
+     * Returns whether the given string could potentially be a valid number. This should be used to
+     * validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+     * of the minus/plus sign characters can be checked.
+     */
+    isValidPartialNumber(value: string, minValue?: number, maxValue?: number): boolean;
+    /**
+     * Returns a numbering system for which the given string is valid in the current locale.
+     * If no numbering system could be detected, the default numbering system for the current
+     * locale is returned.
+     */
+    getNumberingSystem(value: string): string;
+}

package/number/NumberParser.js

@@ -0,0 +1,316 @@
+// Ported from @internationalized/number src/NumberParser.ts (react-spectrum, v3.6.8), Apache-2.0, © Adobe.
+// Changes: .ts import specifier, strict-mode parameter type on the numeral index callback, formatting (repo prettier).
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { NumberFormatter } from "./NumberFormatter.js";
+const CURRENCY_SIGN_REGEX = new RegExp("^.*\\(.*\\).*$");
+const NUMBERING_SYSTEMS = ["latn", "arab", "hanidec", "deva", "beng", "fullwide"];
+/**
+ * A NumberParser can be used to perform locale-aware parsing of numbers from Unicode strings,
+ * as well as validation of partial user input. It automatically detects the numbering system
+ * used in the input, and supports parsing decimals, percentages, currency values, and units
+ * according to the locale.
+ */
+export class NumberParser {
+    locale;
+    options;
+    constructor(locale, options = {}) {
+        this.locale = locale;
+        this.options = options;
+    }
+    /**
+     * Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+     */
+    parse(value) {
+        return getNumberParserImpl(this.locale, this.options, value).parse(value);
+    }
+    /**
+     * Returns whether the given string could potentially be a valid number. This should be used to
+     * validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+     * of the minus/plus sign characters can be checked.
+     */
+    isValidPartialNumber(value, minValue, maxValue) {
+        return getNumberParserImpl(this.locale, this.options, value).isValidPartialNumber(value, minValue, maxValue);
+    }
+    /**
+     * Returns a numbering system for which the given string is valid in the current locale.
+     * If no numbering system could be detected, the default numbering system for the current
+     * locale is returned.
+     */
+    getNumberingSystem(value) {
+        return getNumberParserImpl(this.locale, this.options, value).options.numberingSystem;
+    }
+}
+const numberParserCache = new Map();
+function getNumberParserImpl(locale, options, value) {
+    // First try the default numbering system for the provided locale
+    let defaultParser = getCachedNumberParser(locale, options);
+    // If that doesn't match, and the locale doesn't include a hard coded numbering system,
+    // try each of the other supported numbering systems until we find one that matches.
+    if (!locale.includes("-nu-") && !defaultParser.isValidPartialNumber(value)) {
+        for (let numberingSystem of NUMBERING_SYSTEMS) {
+            if (numberingSystem !== defaultParser.options.numberingSystem) {
+                let parser = getCachedNumberParser(locale + (locale.includes("-u-") ? "-nu-" : "-u-nu-") + numberingSystem, options);
+                if (parser.isValidPartialNumber(value)) {
+                    return parser;
+                }
+            }
+        }
+    }
+    return defaultParser;
+}
+function getCachedNumberParser(locale, options) {
+    let cacheKey = locale +
+        (options
+            ? Object.entries(options)
+                .sort((a, b) => (a[0] < b[0] ? -1 : 1))
+                .join()
+            : "");
+    let parser = numberParserCache.get(cacheKey);
+    if (!parser) {
+        parser = new NumberParserImpl(locale, options);
+        numberParserCache.set(cacheKey, parser);
+    }
+    return parser;
+}
+// The actual number parser implementation. Instances of this class are cached
+// based on the locale, options, and detected numbering system.
+class NumberParserImpl {
+    formatter;
+    options;
+    symbols;
+    locale;
+    constructor(locale, options = {}) {
+        this.locale = locale;
+        // see https://tc39.es/ecma402/#sec-setnfdigitoptions, when using roundingIncrement, the maximumFractionDigits and minimumFractionDigits must be equal
+        // by default, they are 0 and 3 respectively, so we set them to 0 if neither are set
+        if (options.roundingIncrement !== 1 && options.roundingIncrement != null) {
+            if (options.maximumFractionDigits == null && options.minimumFractionDigits == null) {
+                options.maximumFractionDigits = 0;
+                options.minimumFractionDigits = 0;
+            }
+            else if (options.maximumFractionDigits == null) {
+                options.maximumFractionDigits = options.minimumFractionDigits;
+            }
+            else if (options.minimumFractionDigits == null) {
+                options.minimumFractionDigits = options.maximumFractionDigits;
+            }
+            // if both are specified, let the normal Range Error be thrown
+        }
+        this.formatter = new Intl.NumberFormat(locale, options);
+        this.options = this.formatter.resolvedOptions();
+        this.symbols = getSymbols(locale, this.formatter, this.options, options);
+        if (this.options.style === "percent" && ((this.options.minimumFractionDigits ?? 0) > 18 || (this.options.maximumFractionDigits ?? 0) > 18)) {
+            console.warn("NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.");
+        }
+    }
+    parse(value) {
+        let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+        // to parse the number, we need to remove anything that isn't actually part of the number, for example we want '-10.40' not '-10.40 USD'
+        let fullySanitizedValue = this.sanitize(value);
+        // Return NaN if there is a group symbol but useGrouping is false
+        if (!isGroupSymbolAllowed && this.symbols.group && fullySanitizedValue.includes(this.symbols.group)) {
+            return NaN;
+        }
+        else if (this.symbols.group) {
+            fullySanitizedValue = fullySanitizedValue.replaceAll(this.symbols.group, "");
+        }
+        if (this.symbols.decimal) {
+            fullySanitizedValue = fullySanitizedValue.replace(this.symbols.decimal, ".");
+        }
+        if (this.symbols.minusSign) {
+            fullySanitizedValue = fullySanitizedValue.replace(this.symbols.minusSign, "-");
+        }
+        fullySanitizedValue = fullySanitizedValue.replace(this.symbols.numeral, this.symbols.index);
+        if (this.options.style === "percent") {
+            // javascript is bad at dividing by 100 and maintaining the same significant figures, so perform it on the string before parsing
+            let isNegative = fullySanitizedValue.indexOf("-");
+            fullySanitizedValue = fullySanitizedValue.replace("-", "");
+            fullySanitizedValue = fullySanitizedValue.replace("+", "");
+            let index = fullySanitizedValue.indexOf(".");
+            if (index === -1) {
+                index = fullySanitizedValue.length;
+            }
+            fullySanitizedValue = fullySanitizedValue.replace(".", "");
+            if (index - 2 === 0) {
+                fullySanitizedValue = `0.${fullySanitizedValue}`;
+            }
+            else if (index - 2 === -1) {
+                fullySanitizedValue = `0.0${fullySanitizedValue}`;
+            }
+            else if (index - 2 === -2) {
+                fullySanitizedValue = "0.00";
+            }
+            else {
+                fullySanitizedValue = `${fullySanitizedValue.slice(0, index - 2)}.${fullySanitizedValue.slice(index - 2)}`;
+            }
+            if (isNegative > -1) {
+                fullySanitizedValue = `-${fullySanitizedValue}`;
+            }
+        }
+        let newValue = fullySanitizedValue ? +fullySanitizedValue : NaN;
+        if (isNaN(newValue)) {
+            return NaN;
+        }
+        if (this.options.style === "percent") {
+            // extra step for rounding percents to what our formatter would output
+            let options = {
+                ...this.options,
+                style: "decimal",
+                minimumFractionDigits: Math.min((this.options.minimumFractionDigits ?? 0) + 2, 20),
+                maximumFractionDigits: Math.min((this.options.maximumFractionDigits ?? 0) + 2, 20),
+            };
+            return new NumberParser(this.locale, options).parse(new NumberFormatter(this.locale, options).format(newValue));
+        }
+        // accounting will always be stripped to a positive number, so if it's accounting and has a () around everything, then we need to make it negative again
+        if (this.options.currencySign === "accounting" && CURRENCY_SIGN_REGEX.test(value)) {
+            newValue = -1 * newValue;
+        }
+        return newValue;
+    }
+    sanitize(value) {
+        let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+        // If the value is only a unit and it matches one of the formatted numbers where the value is part of the unit and doesn't have any numerals, then
+        // return the known value for that case.
+        if (this.symbols.noNumeralUnits.length > 0 && this.symbols.noNumeralUnits.find((obj) => obj.unit === value)) {
+            return this.symbols.noNumeralUnits.find((obj) => obj.unit === value).value.toString();
+        }
+        value = value.replace(this.symbols.literals, "");
+        // Replace the ASCII minus sign with the minus sign used in the current locale
+        // so that both are allowed in case the user's keyboard doesn't have the locale's minus sign.
+        if (this.symbols.minusSign) {
+            value = value.replace("-", this.symbols.minusSign);
+        }
+        // In arab numeral system, their decimal character is 1643, but most keyboards don't type that
+        // instead they use the , (44) character or apparently the (1548) character.
+        if (this.options.numberingSystem === "arab") {
+            if (this.symbols.decimal) {
+                value = replaceAll(value, ",", this.symbols.decimal);
+                value = replaceAll(value, String.fromCharCode(1548), this.symbols.decimal);
+            }
+            if (this.symbols.group && isGroupSymbolAllowed) {
+                value = replaceAll(value, ".", this.symbols.group);
+            }
+        }
+        // In some locale styles, such as swiss currency, the group character can be a special single quote
+        // that keyboards don't typically have. This expands the character to include the easier to type single quote.
+        if (this.symbols.group === "’" && value.includes("'") && isGroupSymbolAllowed) {
+            value = replaceAll(value, "'", this.symbols.group);
+        }
+        // On newer ICU versions, the special single quote has been normalized, so we need to backport.
+        if (this.symbols.group === "'" && value.includes("’") && isGroupSymbolAllowed) {
+            value = replaceAll(value, "’", this.symbols.group);
+        }
+        // fr-FR group character is narrow non-breaking space, char code 8239 (U+202F), but that's not a key on the french keyboard,
+        // so allow space and non-breaking space as a group char as well
+        if (this.options.locale === "fr-FR" && this.symbols.group && isGroupSymbolAllowed) {
+            value = replaceAll(value, " ", this.symbols.group);
+            value = replaceAll(value, /\u00A0/g, this.symbols.group);
+        }
+        return value;
+    }
+    isValidPartialNumber(value, minValue = -Infinity, maxValue = Infinity) {
+        let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+        value = this.sanitize(value);
+        // Remove minus or plus sign, which must be at the start of the string.
+        if (this.symbols.minusSign && value.startsWith(this.symbols.minusSign) && minValue < 0) {
+            value = value.slice(this.symbols.minusSign.length);
+        }
+        else if (this.symbols.plusSign && value.startsWith(this.symbols.plusSign) && maxValue > 0) {
+            value = value.slice(this.symbols.plusSign.length);
+        }
+        // Numbers that can't have any decimal values fail if a decimal character is typed
+        if (this.symbols.decimal && value.indexOf(this.symbols.decimal) > -1 && this.options.maximumFractionDigits === 0) {
+            return false;
+        }
+        // Remove numerals, groups, and decimals
+        if (this.symbols.group && isGroupSymbolAllowed) {
+            value = replaceAll(value, this.symbols.group, "");
+        }
+        value = value.replace(this.symbols.numeral, "");
+        if (this.symbols.decimal) {
+            value = value.replace(this.symbols.decimal, "");
+        }
+        // The number is valid if there are no remaining characters
+        return value.length === 0;
+    }
+}
+const nonLiteralParts = new Set(["decimal", "fraction", "integer", "minusSign", "plusSign", "group"]);
+// This list is derived from https://www.unicode.org/cldr/charts/49/supplemental/language_plural_rules.html#comparison and includes
+// all unique numbers which we need to check in order to determine all the plural forms for a given locale.
+// Run scripts/generateAllPlurals.mjs to generate this list.
+const pluralNumbers = [0, 4, 2, 1, 11, 20, 3, 7, 100, 21, 0.1, 1.1];
+function getSymbols(locale, formatter, intlOptions, originalOptions) {
+    // formatter needs access to all decimal places in order to generate the correct literal strings for the plural set
+    let symbolFormatter = new Intl.NumberFormat(locale, {
+        ...intlOptions,
+        // Resets so we get the full range of symbols
+        minimumSignificantDigits: 1,
+        maximumSignificantDigits: 21,
+        roundingIncrement: 1,
+        roundingPriority: "auto",
+        roundingMode: "halfExpand",
+        useGrouping: true,
+    });
+    // Note: some locale's don't add a group symbol until there is a ten thousands place
+    let allParts = symbolFormatter.formatToParts(-10000.111);
+    let posAllParts = symbolFormatter.formatToParts(10000.111);
+    let pluralParts = pluralNumbers.map((n) => symbolFormatter.formatToParts(n));
+    // if the plural parts include a unit but no integer or fraction, then we need to add the unit to the special set
+    let noNumeralUnits = pluralParts
+        .map((p, i) => {
+        let unit = p.find((p) => p.type === "unit");
+        if (unit && !p.some((p) => p.type === "integer" || p.type === "fraction")) {
+            return { unit: unit.value, value: pluralNumbers[i] };
+        }
+        return null;
+    })
+        .filter((p) => !!p);
+    let minusSign = allParts.find((p) => p.type === "minusSign")?.value ?? "-";
+    let plusSign = posAllParts.find((p) => p.type === "plusSign")?.value;
+    // Safari does not support the signDisplay option, but our number parser polyfills it.
+    // If no plus sign was returned, but the original options contained signDisplay, default to the '+' character.
+    if (!plusSign && (originalOptions?.signDisplay === "exceptZero" || originalOptions?.signDisplay === "always")) {
+        plusSign = "+";
+    }
+    // If maximumSignificantDigits is 1 (the minimum) then we won't get decimal characters out of the above formatters
+    // Percent also defaults to 0 fractionDigits, so we need to make a new one that isn't percent to get an accurate decimal
+    let decimalParts = new Intl.NumberFormat(locale, {
+        ...intlOptions,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).formatToParts(0.001);
+    let decimal = decimalParts.find((p) => p.type === "decimal")?.value;
+    let group = allParts.find((p) => p.type === "group")?.value;
+    // this set is also for a regex, it's all literals that might be in the string we want to eventually parse that
+    // don't contribute to the numerical value
+    let allPartsLiterals = allParts.filter((p) => !nonLiteralParts.has(p.type)).map((p) => escapeRegex(p.value));
+    let pluralPartsLiterals = pluralParts.flatMap((p) => p.filter((p) => !nonLiteralParts.has(p.type)).map((p) => escapeRegex(p.value)));
+    let sortedLiterals = [...new Set([...allPartsLiterals, ...pluralPartsLiterals])].sort((a, b) => b.length - a.length);
+    // Match both whitespace and formatting characters
+    let literals = sortedLiterals.length === 0 ? new RegExp("\\p{White_Space}|\\p{Cf}", "gu") : new RegExp(`${sortedLiterals.join("|")}|\\p{White_Space}|\\p{Cf}`, "gu");
+    // These are for replacing non-latn characters with the latn equivalent
+    let numerals = [...new Intl.NumberFormat(intlOptions.locale, { useGrouping: false }).format(9876543210)].reverse();
+    let indexes = new Map(numerals.map((d, i) => [d, i]));
+    let numeral = new RegExp(`[${numerals.join("")}]`, "g");
+    let index = (d) => String(indexes.get(d));
+    return { minusSign, plusSign, decimal, group, literals, numeral, numerals, index, noNumeralUnits };
+}
+function replaceAll(str, find, replace) {
+    if (str.replaceAll) {
+        return str.replaceAll(find, replace);
+    }
+    return str.split(find).join(replace);
+}
+function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/number/index.d.ts

@@ -0,0 +1,5 @@
+export type { NumberFormatOptions } from "./NumberFormatter.js";
+export { NumberFormatter } from "./NumberFormatter.js";
+export { NumberParser } from "./NumberParser.js";
+export type { NumberFieldProps, NumberFieldState, NumberFieldStateOptions, NumberFieldSync } from "./number-field-state.jsx";
+export { createNumberFieldState, committedValue, inputValue, formattedValue, numberValue, minValue, maxValue, canIncrement, canDecrement, validate, setInputValue, setNumberValue, commit, increment, decrement, incrementToMax, decrementToMin, } from "./number-field-state.jsx";

package/number/index.jsx

@@ -0,0 +1,17 @@
+// Ported from @internationalized/number src/index.ts (react-spectrum, v3.6.8), Apache-2.0, © Adobe,
+// plus react-stately `useNumberFieldState` (packages/react-stately/src/numberfield) as `createNumberFieldState`.
+// Changes: .ts import specifiers; Rivet: number field state factory exported beside the formatter / parser.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+export { NumberFormatter } from "./NumberFormatter.js";
+export { NumberParser } from "./NumberParser.js";
+export { createNumberFieldState, committedValue, inputValue, formattedValue, numberValue, minValue, maxValue, canIncrement, canDecrement, validate, setInputValue, setNumberValue, commit, increment, decrement, incrementToMax, decrementToMin, } from "./number-field-state.jsx";