@kanso-labs/react-native-kanso-ui 0.0.0-stage → 0.1.1

package/dist/number/state.js

@@ -0,0 +1,235 @@
+import { NumberParser } from "./parser.js";
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+import { NumberFormatter } from "@internationalized/number";
+//#region src/number/state.ts
+function clamp(value, min = -Infinity, max = Infinity) {
+	return Math.min(Math.max(value, min), max);
+}
+function handleDecimalOperation(operator, value1, value2) {
+	let result = operator === "+" ? value1 + value2 : value1 - value2;
+	if (value1 % 1 !== 0 || value2 % 1 !== 0) {
+		const value1Decimal = value1.toString().split(".");
+		const value2Decimal = value2.toString().split(".");
+		const value1DecimalLength = value1Decimal[1]?.length ?? 0;
+		const value2DecimalLength = value2Decimal[1]?.length ?? 0;
+		const multiplier = 10 ** Math.max(value1DecimalLength, value2DecimalLength);
+		const whole1 = Math.round(value1 * multiplier);
+		const whole2 = Math.round(value2 * multiplier);
+		result = operator === "+" ? whole1 + whole2 : whole1 - whole2;
+		result /= multiplier;
+	}
+	return result;
+}
+function isEqualFormatOptions(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	const bValues = new Map(Object.entries(b));
+	const aEntries = Object.entries(a);
+	return aEntries.length === bValues.size && aEntries.every(([key, value]) => bValues.has(key) && bValues.get(key) === value);
+}
+function roundToStepPrecision(value, step) {
+	let precision = 0;
+	const stepString = step.toString();
+	const exponent = stepString.toLowerCase().indexOf("e-");
+	if (exponent > 0) precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + exponent;
+	else {
+		const point = stepString.indexOf(".");
+		if (point >= 0) precision = stepString.length - point;
+	}
+	if (precision > 0) {
+		const pow = 10 ** precision;
+		return Math.round(value * pow) / pow;
+	}
+	return value;
+}
+function snapValueToStep(value, minValue, maxValue, step) {
+	const min = Number(minValue);
+	const max = Number(maxValue);
+	const remainder = (value - (Number.isNaN(min) ? 0 : min)) % step;
+	let snapped = roundToStepPrecision(Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder, step);
+	if (!Number.isNaN(min)) {
+		if (snapped < min) snapped = min;
+		else if (!Number.isNaN(max) && snapped > max) snapped = min + Math.floor(roundToStepPrecision((max - min) / step, step)) * step;
+	} else if (!Number.isNaN(max) && snapped > max) snapped = Math.floor(roundToStepPrecision(max / step, step)) * step;
+	return roundToStepPrecision(snapped, step);
+}
+/**
+* The state of a number field: what its input holds, the number that reads
+* as, and stepping and committing it. Pass `value` with `onChange` to
+* control it, or `defaultValue` to let it keep its own; `onChange` is handed
+* the committed number, `NaN` for an empty field.
+*/
+function useNumberFieldState(t0) {
+	const $ = c(45);
+	const { defaultValue: t1, formatOptions, isDisabled: t2, isReadOnly: t3, locale, maxValue, minValue, onChange, step, value: givenValue } = t0;
+	const givenDefault = t1 === void 0 ? NaN : t1;
+	const isDisabled = t2 === void 0 ? false : t2;
+	const isReadOnly = t3 === void 0 ? false : t3;
+	let t4;
+	if ($[0] !== step) {
+		t4 = step === void 0 || Number.isNaN(step);
+		$[0] = step;
+		$[1] = t4;
+	} else t4 = $[1];
+	const stepless = t4;
+	let t5;
+	if ($[2] !== maxValue || $[3] !== minValue || $[4] !== step || $[5] !== stepless) {
+		t5 = (value) => stepless ? clamp(value, minValue, maxValue) : snapValueToStep(value, minValue, maxValue, step);
+		$[2] = maxValue;
+		$[3] = minValue;
+		$[4] = step;
+		$[5] = stepless;
+		$[6] = t5;
+	} else t5 = $[6];
+	const snapValue = t5;
+	const nulled = givenValue === null ? NaN : givenValue;
+	let t6;
+	if ($[7] !== nulled || $[8] !== snapValue) {
+		t6 = nulled === void 0 || Number.isNaN(nulled) ? nulled : snapValue(nulled);
+		$[7] = nulled;
+		$[8] = snapValue;
+		$[9] = t6;
+	} else t6 = $[9];
+	const value_0 = t6;
+	let t7;
+	if ($[10] !== givenDefault || $[11] !== snapValue) {
+		t7 = Number.isNaN(givenDefault) ? givenDefault : snapValue(givenDefault);
+		$[10] = givenDefault;
+		$[11] = snapValue;
+		$[12] = t7;
+	} else t7 = $[12];
+	const [own, setOwn] = useState(t7);
+	const controlled = value_0 !== void 0;
+	const numberValue = controlled ? value_0 : own;
+	let t8;
+	if ($[13] !== controlled || $[14] !== numberValue || $[15] !== onChange) {
+		t8 = (next) => {
+			if (!controlled) setOwn(next);
+			if (!Object.is(numberValue, next)) onChange?.(next);
+		};
+		$[13] = controlled;
+		$[14] = numberValue;
+		$[15] = onChange;
+		$[16] = t8;
+	} else t8 = $[16];
+	const setNumberValue = t8;
+	let t9;
+	if ($[17] !== formatOptions || $[18] !== locale || $[19] !== numberValue) {
+		t9 = () => Number.isNaN(numberValue) ? "" : new NumberFormatter(locale, formatOptions).format(numberValue);
+		$[17] = formatOptions;
+		$[18] = locale;
+		$[19] = numberValue;
+		$[20] = t9;
+	} else t9 = $[20];
+	const [inputValue, setInputValue] = useState(t9);
+	let t10;
+	if ($[21] !== formatOptions || $[22] !== locale) {
+		t10 = new NumberParser(locale, formatOptions);
+		$[21] = formatOptions;
+		$[22] = locale;
+		$[23] = t10;
+	} else t10 = $[23];
+	const parser = t10;
+	const numberingSystem = parser.getNumberingSystem(inputValue);
+	const formatter = new NumberFormatter(locale, {
+		...formatOptions,
+		numberingSystem
+	});
+	const format = (next_0) => Number.isNaN(next_0) ? "" : formatter.format(next_0);
+	const clampStep = stepless ? formatter.resolvedOptions().style === "percent" ? .01 : 1 : step;
+	const [previousValue, setPreviousValue] = useState(numberValue);
+	const [previousLocale, setPreviousLocale] = useState(locale);
+	const [previousFormat, setPreviousFormat] = useState(formatOptions);
+	if (!Object.is(numberValue, previousValue) || locale !== previousLocale || !isEqualFormatOptions(formatOptions, previousFormat)) {
+		setInputValue(format(numberValue));
+		setPreviousValue(numberValue);
+		setPreviousLocale(locale);
+		setPreviousFormat(formatOptions);
+	}
+	const parsedValue = parser.parse(inputValue);
+	const commit = () => {
+		if (inputValue.length === 0) {
+			setNumberValue(NaN);
+			setInputValue(value_0 === void 0 ? "" : format(numberValue));
+			return;
+		}
+		if (Number.isNaN(parsedValue)) {
+			setInputValue(format(numberValue));
+			return;
+		}
+		const next_1 = parser.parse(format(snapValue(parsedValue)));
+		setNumberValue(next_1);
+		setInputValue(format(value_0 === void 0 ? next_1 : numberValue));
+	};
+	const safeNextStep = (operation, t11) => {
+		const bound = t11 === void 0 ? 0 : t11;
+		if (Number.isNaN(parsedValue)) return snapValueToStep(Number.isNaN(bound) ? 0 : bound, minValue, maxValue, clampStep);
+		const snapped = snapValueToStep(parsedValue, minValue, maxValue, clampStep);
+		if (operation === "+" && snapped > parsedValue || operation === "-" && snapped < parsedValue) return snapped;
+		return snapValueToStep(handleDecimalOperation(operation, parsedValue, clampStep), minValue, maxValue, clampStep);
+	};
+	const stepTo = (next_2) => {
+		if (next_2 === numberValue) setInputValue(format(next_2));
+		setNumberValue(next_2);
+	};
+	const editable = !isDisabled && !isReadOnly;
+	const canIncrement = editable && (Number.isNaN(parsedValue) || maxValue === void 0 || Number.isNaN(maxValue) || snapValueToStep(parsedValue, minValue, maxValue, clampStep) > parsedValue || handleDecimalOperation("+", parsedValue, clampStep) <= maxValue);
+	const canDecrement = editable && (Number.isNaN(parsedValue) || minValue === void 0 || Number.isNaN(minValue) || snapValueToStep(parsedValue, minValue, maxValue, clampStep) < parsedValue || handleDecimalOperation("-", parsedValue, clampStep) >= minValue);
+	let t12;
+	if ($[24] !== maxValue || $[25] !== safeNextStep || $[26] !== stepTo) {
+		t12 = () => {
+			stepTo(safeNextStep("-", maxValue));
+		};
+		$[24] = maxValue;
+		$[25] = safeNextStep;
+		$[26] = stepTo;
+		$[27] = t12;
+	} else t12 = $[27];
+	let t13;
+	if ($[28] !== minValue || $[29] !== safeNextStep || $[30] !== stepTo) {
+		t13 = () => {
+			stepTo(safeNextStep("+", minValue));
+		};
+		$[28] = minValue;
+		$[29] = safeNextStep;
+		$[30] = stepTo;
+		$[31] = t13;
+	} else t13 = $[31];
+	let t14;
+	if ($[32] !== maxValue || $[33] !== minValue || $[34] !== parser) {
+		t14 = (next_3) => parser.isValidPartialNumber(next_3, minValue, maxValue);
+		$[32] = maxValue;
+		$[33] = minValue;
+		$[34] = parser;
+		$[35] = t14;
+	} else t14 = $[35];
+	let t15;
+	if ($[36] !== canDecrement || $[37] !== canIncrement || $[38] !== commit || $[39] !== inputValue || $[40] !== parsedValue || $[41] !== t12 || $[42] !== t13 || $[43] !== t14) {
+		t15 = {
+			canDecrement,
+			canIncrement,
+			commit,
+			decrement: t12,
+			increment: t13,
+			inputValue,
+			numberValue: parsedValue,
+			setInputValue,
+			validate: t14
+		};
+		$[36] = canDecrement;
+		$[37] = canIncrement;
+		$[38] = commit;
+		$[39] = inputValue;
+		$[40] = parsedValue;
+		$[41] = t12;
+		$[42] = t13;
+		$[43] = t14;
+		$[44] = t15;
+	} else t15 = $[44];
+	return t15;
+}
+//#endregion
+export { useNumberFieldState };
+
+//# sourceMappingURL=state.js.map

package/dist/number/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","names":["NumberFormatOptions","NumberFormatter","useMemo","useState","NumberParser","NumberFieldState","canDecrement","canIncrement","commit","decrement","increment","inputValue","numberValue","setInputValue","value","validate","NumberFieldStateOptions","defaultValue","formatOptions","isDisabled","isReadOnly","locale","maxValue","minValue","onChange","step","clamp","min","Infinity","max","Math","handleDecimalOperation","operator","value1","value2","result","value1Decimal","toString","split","value2Decimal","value1DecimalLength","length","value2DecimalLength","multiplier","whole1","round","whole2","isEqualFormatOptions","a","b","undefined","bValues","Map","Object","entries","aEntries","size","every","key","has","get","roundToStepPrecision","precision","stepString","exponent","toLowerCase","indexOf","abs","floor","log10","point","pow","snapValueToStep","Number","remainder","isNaN","snapped","sign","useNumberFieldState","t0","$","_c","t1","t2","t3","givenValue","givenDefault","NaN","t4","stepless","t5","snapValue","nulled","t6","value_0","t7","own","setOwn","controlled","t8","next","is","setNumberValue","t9","format","t10","parser","numberingSystem","getNumberingSystem","formatter","next_0","clampStep","resolvedOptions","style","previousValue","setPreviousValue","previousLocale","setPreviousLocale","previousFormat","setPreviousFormat","parsedValue","parse","next_1","safeNextStep","operation","t11","bound","stepTo","next_2","editable","t12","t13","t14","next_3","isValidPartialNumber","t15","_c","defaultValue"],"sources":["../../src/number/state.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n *\n * Modified by Kanso Labs: ported from React Stately's useNumberFieldState and\n * the number utilities beside it, reading values through ./parser and\n * leaving form validation to the field.\n */\n\nimport type { NumberFormatOptions } from '@internationalized/number'\n\nimport { NumberFormatter } from '@internationalized/number'\nimport { useMemo, useState } from 'react'\n\nimport { NumberParser } from './parser'\n\n// The state behind NumberField: the text in its input, the number that text\n// reads as, and the steps either way. It is React Stately's\n// `useNumberFieldState`, which web's NumberField reads through React Aria,\n// so the two take a value alike: a keystroke is kept only where the text\n// could still become a number in the field's locale and format, and a\n// commit, on blur or the return key, reads the text, clamps it to the\n// range, snaps it to the step and rounds it as the format shows it, then\n// writes it back formatted. The field's validity is its `error` alone, so\n// none of React Stately's form validation comes with it.\n\ntype NumberFieldState = {\n  /** Whether a decrement would lower the value, given the range and step. */\n  readonly canDecrement: boolean\n  /** Whether an increment would raise the value, given the range and step. */\n  readonly canIncrement: boolean\n  /**\n   * Reads the text as a number, clamps and snaps it, reports it through\n   * `onChange`, and writes it back formatted.\n   */\n  readonly commit: () => void\n  /** Steps the value down to the step boundary below it. */\n  readonly decrement: () => void\n  /** Steps the value up to the step boundary above it. */\n  readonly increment: () => void\n  /** The text in the input, as typed until it is committed. */\n  readonly inputValue: string\n  /** The number the text reads as, or `NaN` while it reads as none. */\n  readonly numberValue: number\n  /** Sets the text in the input. */\n  readonly setInputValue: (value: string) => void\n  /** Whether the text could still become a number, as it is typed. */\n  readonly validate: (value: string) => boolean\n}\n\ntype NumberFieldStateOptions = {\n  readonly defaultValue?: number | undefined\n  readonly formatOptions?: NumberFormatOptions | undefined\n  readonly isDisabled?: boolean | undefined\n  readonly isReadOnly?: boolean | undefined\n  readonly locale: string\n  readonly maxValue?: number | undefined\n  readonly minValue?: number | undefined\n  readonly onChange?: ((value: number) => void) | undefined\n  readonly step?: number | undefined\n  readonly value?: null | number | undefined\n}\n\nfunction clamp(value: number, min = -Infinity, max = Infinity) {\n  return Math.min(Math.max(value, min), max)\n}\n\n// Adds or subtracts on whole numbers when either side has a fraction, so\n// 0.1 + 0.2 steps to 0.3 rather than to 0.30000000000000004.\nfunction handleDecimalOperation(\n  operator: '+' | '-',\n  value1: number,\n  value2: number,\n) {\n  let result = operator === '+' ? value1 + value2 : value1 - value2\n\n  if (value1 % 1 !== 0 || value2 % 1 !== 0) {\n    const value1Decimal = value1.toString().split('.')\n    const value2Decimal = value2.toString().split('.')\n    const value1DecimalLength = value1Decimal[1]?.length ?? 0\n    const value2DecimalLength = value2Decimal[1]?.length ?? 0\n    const multiplier = 10 ** Math.max(value1DecimalLength, value2DecimalLength)\n\n    const whole1 = Math.round(value1 * multiplier)\n    const whole2 = Math.round(value2 * multiplier)\n    result = operator === '+' ? whole1 + whole2 : whole1 - whole2\n    result /= multiplier\n  }\n\n  return result\n}\n\n// Shallow, since every value a format takes is a primitive.\nfunction isEqualFormatOptions(\n  a: NumberFormatOptions | undefined,\n  b: NumberFormatOptions | undefined,\n) {\n  if (a === b) {\n    return true\n  }\n  if (a === undefined || b === undefined) {\n    return false\n  }\n\n  const bValues = new Map<string, unknown>(Object.entries(b))\n  const aEntries: [string, unknown][] = Object.entries(a)\n  return (\n    aEntries.length === bValues.size &&\n    aEntries.every(\n      ([key, value]) => bValues.has(key) && bValues.get(key) === value,\n    )\n  )\n}\n\n// A value rounded to as many decimal places as the step has, which takes\n// the floating point error off a value a step was added to.\nfunction roundToStepPrecision(value: number, step: number) {\n  let precision = 0\n  const stepString = step.toString()\n  const exponent = stepString.toLowerCase().indexOf('e-')\n\n  if (exponent > 0) {\n    precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + exponent\n  } else {\n    const point = stepString.indexOf('.')\n    if (point >= 0) {\n      precision = stepString.length - point\n    }\n  }\n\n  if (precision > 0) {\n    const pow = 10 ** precision\n    return Math.round(value * pow) / pow\n  }\n\n  return value\n}\n\n// The nearest value a whole number of steps from the minimum, or from zero\n// with no minimum, inside the range.\nfunction snapValueToStep(\n  value: number,\n  minValue: number | undefined,\n  maxValue: number | undefined,\n  step: number,\n) {\n  const min = Number(minValue)\n  const max = Number(maxValue)\n  const remainder = (value - (Number.isNaN(min) ? 0 : min)) % step\n  let snapped = roundToStepPrecision(\n    Math.abs(remainder) * 2 >= step\n      ? value + Math.sign(remainder) * (step - Math.abs(remainder))\n      : value - remainder,\n    step,\n  )\n\n  if (!Number.isNaN(min)) {\n    if (snapped < min) {\n      snapped = min\n    } else if (!Number.isNaN(max) && snapped > max) {\n      snapped =\n        min + Math.floor(roundToStepPrecision((max - min) / step, step)) * step\n    }\n  } else if (!Number.isNaN(max) && snapped > max) {\n    snapped = Math.floor(roundToStepPrecision(max / step, step)) * step\n  }\n\n  return roundToStepPrecision(snapped, step)\n}\n\n/**\n * The state of a number field: what its input holds, the number that reads\n * as, and stepping and committing it. Pass `value` with `onChange` to\n * control it, or `defaultValue` to let it keep its own; `onChange` is handed\n * the committed number, `NaN` for an empty field.\n */\nfunction useNumberFieldState({\n  defaultValue: givenDefault = Number.NaN,\n  formatOptions,\n  isDisabled = false,\n  isReadOnly = false,\n  locale,\n  maxValue,\n  minValue,\n  onChange,\n  step,\n  value: givenValue,\n}: NumberFieldStateOptions): NumberFieldState {\n  const stepless = step === undefined || Number.isNaN(step)\n  const snapValue = (value: number) =>\n    stepless\n      ? clamp(value, minValue, maxValue)\n      : snapValueToStep(value, minValue, maxValue, step)\n\n  const nulled = givenValue === null ? Number.NaN : givenValue\n  const value =\n    nulled === undefined || Number.isNaN(nulled) ? nulled : snapValue(nulled)\n  const defaultValue = Number.isNaN(givenDefault)\n    ? givenDefault\n    : snapValue(givenDefault)\n\n  const [own, setOwn] = useState(defaultValue)\n  const controlled = value !== undefined\n  const numberValue = controlled ? value : own\n  const setNumberValue = (next: number) => {\n    if (!controlled) {\n      setOwn(next)\n    }\n    if (!Object.is(numberValue, next)) {\n      onChange?.(next)\n    }\n  }\n\n  const [inputValue, setInputValue] = useState(() =>\n    Number.isNaN(numberValue)\n      ? ''\n      : new NumberFormatter(locale, formatOptions).format(numberValue),\n  )\n  const parser = useMemo(\n    () => new NumberParser(locale, formatOptions),\n    [locale, formatOptions],\n  )\n  // The numbering system the text is in, which the value is written back\n  // in: digits typed in another script than the locale's stay in it.\n  const numberingSystem = parser.getNumberingSystem(inputValue)\n  const formatter = new NumberFormatter(locale, {\n    ...formatOptions,\n    numberingSystem,\n  })\n  const format = (next: number) =>\n    Number.isNaN(next) ? '' : formatter.format(next)\n\n  // A percentage steps by a whole percent when no step is given.\n  const clampStep = stepless\n    ? formatter.resolvedOptions().style === 'percent'\n      ? 0.01\n      : 1\n    : step\n\n  // The text follows the value, the locale and the format whenever one of\n  // them changes, so a controlled value set from outside is shown.\n  const [previousValue, setPreviousValue] = useState(numberValue)\n  const [previousLocale, setPreviousLocale] = useState(locale)\n  const [previousFormat, setPreviousFormat] = useState(formatOptions)\n  if (\n    !Object.is(numberValue, previousValue) ||\n    locale !== previousLocale ||\n    !isEqualFormatOptions(formatOptions, previousFormat)\n  ) {\n    setInputValue(format(numberValue))\n    setPreviousValue(numberValue)\n    setPreviousLocale(locale)\n    setPreviousFormat(formatOptions)\n  }\n\n  const parsedValue = parser.parse(inputValue)\n\n  const commit = () => {\n    // An empty field is empty.\n    if (inputValue.length === 0) {\n      setNumberValue(Number.NaN)\n      setInputValue(value === undefined ? '' : format(numberValue))\n      return\n    }\n\n    // Text that reads as no number goes back to the value.\n    if (Number.isNaN(parsedValue)) {\n      setInputValue(format(numberValue))\n      return\n    }\n\n    // Clamped, snapped, and rounded as the format shows it.\n    const next = parser.parse(format(snapValue(parsedValue)))\n    setNumberValue(next)\n    // A controlled value the call site keeps is what the text goes back to.\n    setInputValue(format(value === undefined ? next : numberValue))\n  }\n\n  // From an empty field, the bound the step heads away from, or zero. From\n  // a value, the step boundary in the step's direction: the value snapped,\n  // where that moves it that way, or a step on from it.\n  const safeNextStep = (operation: '+' | '-', bound = 0) => {\n    if (Number.isNaN(parsedValue)) {\n      return snapValueToStep(\n        Number.isNaN(bound) ? 0 : bound,\n        minValue,\n        maxValue,\n        clampStep,\n      )\n    }\n\n    const snapped = snapValueToStep(parsedValue, minValue, maxValue, clampStep)\n    if (\n      (operation === '+' && snapped > parsedValue) ||\n      (operation === '-' && snapped < parsedValue)\n    ) {\n      return snapped\n    }\n\n    return snapValueToStep(\n      handleDecimalOperation(operation, parsedValue, clampStep),\n      minValue,\n      maxValue,\n      clampStep,\n    )\n  }\n\n  const stepTo = (next: number) => {\n    // Stepping to the value the field already holds changes no state, so\n    // the text, which may have been edited since, is written back here.\n    if (next === numberValue) {\n      setInputValue(format(next))\n    }\n    setNumberValue(next)\n  }\n\n  const editable = !isDisabled && !isReadOnly\n  const canIncrement =\n    editable &&\n    (Number.isNaN(parsedValue) ||\n      maxValue === undefined ||\n      Number.isNaN(maxValue) ||\n      snapValueToStep(parsedValue, minValue, maxValue, clampStep) >\n        parsedValue ||\n      handleDecimalOperation('+', parsedValue, clampStep) <= maxValue)\n  const canDecrement =\n    editable &&\n    (Number.isNaN(parsedValue) ||\n      minValue === undefined ||\n      Number.isNaN(minValue) ||\n      snapValueToStep(parsedValue, minValue, maxValue, clampStep) <\n        parsedValue ||\n      handleDecimalOperation('-', parsedValue, clampStep) >= minValue)\n\n  return {\n    canDecrement,\n    canIncrement,\n    commit,\n    decrement: () => {\n      stepTo(safeNextStep('-', maxValue))\n    },\n    increment: () => {\n      stepTo(safeNextStep('+', minValue))\n    },\n    inputValue,\n    numberValue: parsedValue,\n    setInputValue,\n    validate: (next) => parser.isValidPartialNumber(next, minValue, maxValue),\n  }\n}\n\nexport { useNumberFieldState }\nexport type { NumberFieldState, NumberFieldStateOptions }\n"],"mappings":"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"}

package/dist/overlay/host.js

@@ -0,0 +1,111 @@
+import { c } from "react/compiler-runtime";
+import { StyleSheet, View } from "react-native";
+import { createContext, useState, useSyncExternalStore } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/overlay/host.tsx
+const OverlayHostContext = createContext(null);
+const styles = StyleSheet.create({ fill: {
+	bottom: 0,
+	left: 0,
+	pointerEvents: "box-none",
+	position: "absolute",
+	right: 0,
+	top: 0
+} });
+/**
+* Hosts the overlays drawn inside it: its children, then a layer over them
+* that fills the view around the host. Mounting or unmounting an overlay
+* renders the layer alone, so the screen under it keeps its state.
+*
+* The outermost `ThemeScope` renders one, so an app has one at its root.
+*/
+function OverlayHost(t0) {
+	const $ = c(6);
+	const { children } = t0;
+	const [store] = useState(storeFor);
+	let t1;
+	if ($[0] !== store) {
+		t1 = /* @__PURE__ */ jsx(OverlayLayer, {
+			attach: store.attach,
+			store
+		});
+		$[0] = store;
+		$[1] = t1;
+	} else t1 = $[1];
+	let t2;
+	if ($[2] !== children || $[3] !== store || $[4] !== t1) {
+		t2 = /* @__PURE__ */ jsxs(OverlayHostContext, {
+			value: store,
+			children: [children, t1]
+		});
+		$[2] = children;
+		$[3] = store;
+		$[4] = t1;
+		$[5] = t2;
+	} else t2 = $[5];
+	return t2;
+}
+function OverlayLayer(t0) {
+	const $ = c(5);
+	const { attach, store } = t0;
+	const entries = useSyncExternalStore(store.subscribe, store.entries);
+	let t1;
+	if ($[0] !== entries) {
+		t1 = entries.map(_temp);
+		$[0] = entries;
+		$[1] = t1;
+	} else t1 = $[1];
+	let t2;
+	if ($[2] !== attach || $[3] !== t1) {
+		t2 = /* @__PURE__ */ jsx(View, {
+			ref: attach,
+			style: styles.fill,
+			children: t1
+		});
+		$[2] = attach;
+		$[3] = t1;
+		$[4] = t2;
+	} else t2 = $[4];
+	return t2;
+}
+function _temp(t0) {
+	const [key, content] = t0;
+	return /* @__PURE__ */ jsx(View, {
+		style: styles.fill,
+		children: content
+	}, key);
+}
+function storeFor() {
+	const content = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let entries = [];
+	let layer = null;
+	const changed = () => {
+		entries = [...content];
+		for (const listener of listeners) listener();
+	};
+	return {
+		attach: (view) => {
+			layer = view;
+		},
+		entries: () => entries,
+		layer: () => layer,
+		remove: (key) => {
+			if (content.delete(key)) changed();
+		},
+		set: (key, node) => {
+			content.set(key, node);
+			changed();
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+export { OverlayHost, OverlayHostContext };
+
+//# sourceMappingURL=host.js.map

package/dist/overlay/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":["ReactNode","createContext","use","useId","useLayoutEffect","useState","useSyncExternalStore","StyleSheet","View","ScopeContext","useScope","Entry","key","content","OverlayStore","attach","layer","entries","remove","set","subscribe","listener","OverlayHostContext","styles","create","fill","bottom","left","pointerEvents","position","right","top","Overlay","t0","$","_c","children","store","scope","Error","t1","t2","t3","t4","OverlayHost","storeFor","OverlayLayer","map","_temp","Map","listeners","Set","changed","view","delete","node","add","_c"],"sources":["../../src/overlay/host.tsx"],"sourcesContent":["import type { ReactNode } from 'react'\n\nimport {\n  createContext,\n  use,\n  useId,\n  useLayoutEffect,\n  useState,\n  useSyncExternalStore,\n} from 'react'\nimport { StyleSheet, View } from 'react-native'\n\nimport { ScopeContext, useScope } from '../theme/scope'\n\ntype Entry = readonly [key: string, content: ReactNode]\n\n/** What an overlay reaches its host through. */\ntype OverlayStore = {\n  /** Takes the layer the host draws its overlays in, as its ref. */\n  readonly attach: (layer: null | View) => void\n  readonly entries: () => readonly Entry[]\n  /** The layer the host draws its overlays in, for placing one in it. */\n  readonly layer: () => null | View\n  readonly remove: (key: string) => void\n  readonly set: (key: string, content: ReactNode) => void\n  readonly subscribe: (listener: () => void) => () => void\n}\n\nconst OverlayHostContext = createContext<null | OverlayStore>(null)\n\nconst styles = StyleSheet.create({\n  // Each overlay fills the layer on a box of its own, so one laid out in the\n  // flow, as a bar along an edge is, is laid out against the screen rather\n  // than after the overlay before it.\n  fill: {\n    bottom: 0,\n    left: 0,\n    pointerEvents: 'box-none',\n    position: 'absolute',\n    right: 0,\n    top: 0,\n  },\n})\n\n/**\n * Draws its content above the screen, in the overlay host of the app's\n * outermost `ThemeScope`, for as long as it is mounted. A later overlay draws\n * above an earlier one.\n *\n * The content reads the `ThemeScope` around the `Overlay`, as anything else\n * there would. Other context set between the host and the `Overlay` does not\n * reach it: an overlay is a surface of its own, as web's `OverlayScope` makes\n * one, so it starts from what is around the app rather than from what is\n * around the control that opened it.\n */\nfunction Overlay({ children }: { readonly children?: ReactNode }) {\n  const store = use(OverlayHostContext)\n  const scope = useScope()\n  const key = useId()\n\n  if (store === null) {\n    throw new Error(\n      'An overlay draws in the host of the outermost ThemeScope, and there is no ThemeScope around this one. Wrap the app in a ThemeScope.',\n    )\n  }\n\n  // Set before paint, so an overlay opening never draws a frame without it,\n  // and replaced in place on an update, so it keeps its place in the stack.\n  useLayoutEffect(() => {\n    store.set(key, <ScopeContext value={scope}>{children}</ScopeContext>)\n  }, [children, key, scope, store])\n\n  useLayoutEffect(\n    () => () => {\n      store.remove(key)\n    },\n    [key, store],\n  )\n\n  return null\n}\n\n/**\n * Hosts the overlays drawn inside it: its children, then a layer over them\n * that fills the view around the host. Mounting or unmounting an overlay\n * renders the layer alone, so the screen under it keeps its state.\n *\n * The outermost `ThemeScope` renders one, so an app has one at its root.\n */\nfunction OverlayHost({ children }: { readonly children?: ReactNode }) {\n  const [store] = useState(storeFor)\n\n  return (\n    <OverlayHostContext value={store}>\n      {children}\n      <OverlayLayer attach={store.attach} store={store} />\n    </OverlayHostContext>\n  )\n}\n\n// The layer passes a touch through to the screen wherever no overlay is\n// drawn, so an open overlay leaves the screen around it usable. It takes its\n// ref apart from the store, since the compiler reads an object a ref is taken\n// from as a ref itself, and the store is read during render.\nfunction OverlayLayer({\n  attach,\n  store,\n}: {\n  readonly attach: OverlayStore['attach']\n  readonly store: OverlayStore\n}) {\n  const entries = useSyncExternalStore(store.subscribe, store.entries)\n\n  return (\n    <View ref={attach} style={styles.fill}>\n      {entries.map(([key, content]) => (\n        <View key={key} style={styles.fill}>\n          {content}\n        </View>\n      ))}\n    </View>\n  )\n}\n\nfunction storeFor(): OverlayStore {\n  const content = new Map<string, ReactNode>()\n  const listeners = new Set<() => void>()\n  let entries: readonly Entry[] = []\n  let layer: null | View = null\n\n  const changed = () => {\n    entries = [...content]\n    for (const listener of listeners) {\n      listener()\n    }\n  }\n\n  return {\n    attach: (view) => {\n      layer = view\n    },\n    entries: () => entries,\n    layer: () => layer,\n    remove: (key) => {\n      if (content.delete(key)) {\n        changed()\n      }\n    },\n    set: (key, node) => {\n      content.set(key, node)\n      changed()\n    },\n    subscribe: (listener) => {\n      listeners.add(listener)\n      return () => {\n        listeners.delete(listener)\n      }\n    },\n  }\n}\n\nexport type { OverlayStore }\n\nexport { Overlay, OverlayHost, OverlayHostContext }\n"],"mappings":";;;;;AA4BA,MAAMsB,qBAAqBrB,cAAmC,IAAI;AAElE,MAAMsB,SAAShB,WAAWiB,OAAO,EAI/BC,MAAM;CACJC,QAAQ;CACRC,MAAM;CACNC,eAAe;CACfC,UAAU;CACVC,OAAO;CACPC,KAAK;AACP,EACF,CAAC;;;;;;;;AA+CD,SAAAa,YAAAX,IAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAqB,MAAA,EAAAC,aAAAH;CACnB,MAAA,CAAAI,SAAgBhC,SAASwC,QAAQ;CAAC,IAAAL;CAAA,IAAAN,EAAA,OAAAG,OAAA;EAK9BG,KAAA,oBAAC,cAAD;GAAsB,QAAAH,MAAKtB;GAAgBsB;EAAK,CAAA;EAAIH,EAAA,KAAAG;EAAAH,EAAA,KAAAM;CAAA,OAAAA,KAAAN,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAE,YAAAF,EAAA,OAAAG,SAAAH,EAAA,OAAAM,IAAA;EAFtDC,KAAA,qBAAC,oBAAD;GAA2BJ,OAAAA;GAA3B,UAAA,CACGD,UACDI,EAFiB;;EAGEN,EAAA,KAAAE;EAAAF,EAAA,KAAAG;EAAAH,EAAA,KAAAM;EAAAN,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,OAHrBO;AAGqB;AAQzB,SAAAK,aAAAb,IAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAAsB,MAAA,EAAApB,QAAAsB,UAAAJ;CAOpB,MAAAhB,UAAgBX,qBAAqB+B,MAAKjB,WAAYiB,MAAKpB,OAAQ;CAAC,IAAAuB;CAAA,IAAAN,EAAA,OAAAjB,SAAA;EAI/DuB,KAAAvB,QAAO8B,IAAKC,KAIZ;EAACd,EAAA,KAAAjB;EAAAiB,EAAA,KAAAM;CAAA,OAAAA,KAAAN,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAnB,UAAAmB,EAAA,OAAAM,IAAA;EALJC,KAAA,oBAAC,MAAD;GAAW1B,KAAAA;GAAe,OAAAQ,OAAME;GAC7Be,UAAAA;EADE,CAAA;EAMEN,EAAA,KAAAnB;EAAAmB,EAAA,KAAAM;EAAAN,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAAA,OANPO;AAMO;AAhBX,SAAAO,MAAAf,IAAA;CAWoB,MAAA,CAAArB,KAAAC,WAAAoB;CAAc,OAC1B,oBAAC,MAAD;EAAuB,OAAAV,OAAME;EAC1BZ,UAAAA;CADE,GAAMD,GAAN;AAEE;AAMf,SAASiC,WAAyB;CAChC,MAAMhC,0BAAU,IAAIoC,IAAuB;CAC3C,MAAMC,4BAAY,IAAIC,IAAgB;CACtC,IAAIlC,UAA4B,CAAA;CAChC,IAAID,QAAqB;CAEzB,MAAMoC,gBAAgB;EACpBnC,UAAU,CAAC,GAAGJ,OAAO;EACrB,KAAK,MAAMQ,YAAY6B,WACrB7B,SAAS;CAEb;CAEA,OAAO;EACLN,SAASsC,SAAS;GAChBrC,QAAQqC;EACV;EACApC,eAAeA;EACfD,aAAaA;EACbE,SAASN,QAAQ;GACf,IAAIC,QAAQyC,OAAO1C,GAAG,GACpBwC,QAAQ;EAEZ;EACAjC,MAAMP,KAAK2C,SAAS;GAClB1C,QAAQM,IAAIP,KAAK2C,IAAI;GACrBH,QAAQ;EACV;EACAhC,YAAYC,aAAa;GACvB6B,UAAUM,IAAInC,QAAQ;GACtB,aAAa;IACX6B,UAAUI,OAAOjC,QAAQ;GAC3B;EACF;CACF;AACF"}