@octanejs/base-ui 0.1.1

package/src/utils/mergeProps.ts

@@ -0,0 +1,206 @@
+// Ported from .base-ui/packages/react/src/merge-props/mergeProps.ts (v1.6.0).
+//
+// Merges sets of props left-to-right, Object.assign-style (rightmost wins) EXCEPT:
+//   - event handlers (`onXxx`) CHAIN — the external (rightmost) handler runs first,
+//     then ours, unless the external handler called `event.preventBaseUIHandler()`;
+//   - `className` strings concatenate (external first);
+//   - `style` objects merge (external keys win).
+// A prop entry may be a getter function `(mergedSoFar) => props`; then it is
+// responsible for its own chaining. `ref` is never merged here.
+//
+// octane adaptation: React makes an event preventable only when it is a SYNTHETIC event
+// (`nativeEvent in event`). octane dispatches NATIVE DOM events, so we attach the
+// `preventBaseUIHandler` shim to ANY event object — the analogue of the radix port using
+// `event.cancelBubble` — so a Base UI part's `preventBaseUIHandler()` coordination works.
+import { mergeObjects } from './mergeObjects';
+
+const EMPTY_PROPS = {};
+
+type AnyProps = Record<string, any>;
+type InputProps = AnyProps | ((otherProps: AnyProps) => AnyProps) | undefined;
+
+export function mergeProps(a: InputProps, b: InputProps): AnyProps;
+export function mergeProps(a: InputProps, b: InputProps, c: InputProps): AnyProps;
+export function mergeProps(a: InputProps, b: InputProps, c: InputProps, d: InputProps): AnyProps;
+export function mergeProps(
+	a: InputProps,
+	b: InputProps,
+	c: InputProps,
+	d: InputProps,
+	e: InputProps,
+): AnyProps;
+export function mergeProps(a: any, b: any, c?: any, d?: any, e?: any): AnyProps {
+	if (!c && !d && !e && !a) {
+		return createInitialMergedProps(b);
+	}
+	let merged = createInitialMergedProps(a);
+	if (b) {
+		merged = mergeInto(merged, b);
+	}
+	if (c) {
+		merged = mergeInto(merged, c);
+	}
+	if (d) {
+		merged = mergeInto(merged, d);
+	}
+	if (e) {
+		merged = mergeInto(merged, e);
+	}
+	return merged;
+}
+
+export function mergePropsN(props: InputProps[]): AnyProps {
+	if (props.length === 0) {
+		return EMPTY_PROPS as AnyProps;
+	}
+	if (props.length === 1) {
+		return createInitialMergedProps(props[0]) as AnyProps;
+	}
+	let merged = createInitialMergedProps(props[0]);
+	for (let i = 1; i < props.length; i += 1) {
+		merged = mergeInto(merged, props[i]);
+	}
+	return merged;
+}
+
+function createInitialMergedProps(inputProps: InputProps): AnyProps {
+	if (isPropsGetter(inputProps)) {
+		return { ...resolvePropsGetter(inputProps, EMPTY_PROPS) };
+	}
+	return copyInitialProps(inputProps);
+}
+
+function mergeInto(merged: AnyProps, inputProps: InputProps): AnyProps {
+	if (isPropsGetter(inputProps)) {
+		return resolvePropsGetter(inputProps, merged);
+	}
+	return mutablyMergeInto(merged, inputProps);
+}
+
+function copyInitialProps(inputProps: AnyProps | undefined): AnyProps {
+	const copiedProps: AnyProps = { ...inputProps };
+	for (const propName in copiedProps) {
+		const propValue = copiedProps[propName];
+		if (isEventHandler(propName, propValue)) {
+			copiedProps[propName] = wrapEventHandler(propValue);
+		}
+	}
+	return copiedProps;
+}
+
+function mutablyMergeInto(mergedProps: AnyProps, externalProps: AnyProps | undefined): AnyProps {
+	if (!externalProps) {
+		return mergedProps;
+	}
+	for (const propName in externalProps) {
+		const externalPropValue = externalProps[propName];
+		switch (propName) {
+			case 'style': {
+				mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
+				break;
+			}
+			case 'className': {
+				mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+				break;
+			}
+			default: {
+				if (isEventHandler(propName, externalPropValue)) {
+					mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
+				} else {
+					mergedProps[propName] = externalPropValue;
+				}
+			}
+		}
+	}
+	return mergedProps;
+}
+
+function isEventHandler(key: string, value: unknown): boolean {
+	// `onX` where X is uppercase; value is a function or undefined. Char-code check
+	// (matches Base UI — faster than a regex).
+	const code0 = key.charCodeAt(0);
+	const code1 = key.charCodeAt(1);
+	const code2 = key.charCodeAt(2);
+	return (
+		code0 === 111 /* o */ &&
+		code1 === 110 /* n */ &&
+		code2 >= 65 /* A */ &&
+		code2 <= 90 /* Z */ &&
+		(typeof value === 'function' || typeof value === 'undefined')
+	);
+}
+
+function isPropsGetter(inputProps: InputProps): inputProps is (props: AnyProps) => AnyProps {
+	return typeof inputProps === 'function';
+}
+
+function resolvePropsGetter(inputProps: InputProps, previousProps: AnyProps): AnyProps {
+	if (isPropsGetter(inputProps)) {
+		return inputProps(previousProps);
+	}
+	return inputProps ?? (EMPTY_PROPS as AnyProps);
+}
+
+// octane: any event object is preventable (octane events are native, never synthetic).
+function isPreventableEvent(event: unknown): event is object {
+	return event != null && typeof event === 'object';
+}
+
+function mergeEventHandlers(
+	ourHandler: Function | undefined,
+	theirHandler: Function | undefined,
+): Function | undefined {
+	if (!theirHandler) {
+		return ourHandler;
+	}
+	if (!ourHandler) {
+		return wrapEventHandler(theirHandler);
+	}
+	return (...args: unknown[]) => {
+		const event = args[0];
+		if (isPreventableEvent(event)) {
+			makeEventPreventable(event);
+			const result = theirHandler(...args);
+			if (!(event as any).baseUIHandlerPrevented) {
+				ourHandler(...args);
+			}
+			return result;
+		}
+		const result = theirHandler(...args);
+		ourHandler(...args);
+		return result;
+	};
+}
+
+function wrapEventHandler(handler: Function | undefined): Function | undefined {
+	if (!handler) {
+		return handler;
+	}
+	return (...args: unknown[]) => {
+		const event = args[0];
+		if (isPreventableEvent(event)) {
+			makeEventPreventable(event);
+		}
+		return handler(...args);
+	};
+}
+
+export function makeEventPreventable<T extends object>(event: T): T {
+	(event as any).preventBaseUIHandler = () => {
+		(event as any).baseUIHandlerPrevented = true;
+	};
+	return event;
+}
+
+export function mergeClassNames(
+	ourClassName: string | undefined,
+	theirClassName: string | undefined,
+): string | undefined {
+	if (theirClassName) {
+		if (ourClassName) {
+			return theirClassName + ' ' + ourClassName;
+		}
+		return theirClassName;
+	}
+	return ourClassName;
+}

package/src/utils/noop.ts

@@ -0,0 +1,4 @@
+// Ported from .base-ui/packages/react/src/internals/noop.ts (@base-ui/utils/empty NOOP).
+// A single shared no-op — context hooks compare against it BY IDENTITY to detect "no
+// provider" (e.g. `context.setValidityData === NOOP`), so it must be one module-level value.
+export function NOOP(): void {}

package/src/utils/number/constants.ts

@@ -0,0 +1,4 @@
+// Ported verbatim from .base-ui/packages/react/src/number-field/utils/constants.ts.
+export const CHANGE_VALUE_TICK_DELAY = 60;
+export const START_AUTO_CHANGE_DELAY = 400;
+export const SCROLLING_POINTER_MOVE_DISTANCE = 8;

package/src/utils/number/parse.ts

@@ -0,0 +1,227 @@
+// Ported verbatim from .base-ui/packages/react/src/number-field/utils/parse.ts. Locale-aware
+// number parsing (multiple numeral systems, currency/unit/percent/permille stripping). Pure —
+// only the `getFormatter` import path changes.
+import { getFormatter } from '../formatNumber';
+
+export const HAN_NUMERALS = ['零', '〇', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
+export const HAN_NUMERAL_TO_DIGIT: Record<string, string> = {
+	零: '0',
+	〇: '0',
+	一: '1',
+	二: '2',
+	三: '3',
+	四: '4',
+	五: '5',
+	六: '6',
+	七: '7',
+	八: '8',
+	九: '9',
+};
+export const ARABIC_NUMERALS = ['٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩'];
+export const PERSIAN_NUMERALS = ['۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹'];
+export const FULLWIDTH_NUMERALS = ['０', '１', '２', '３', '４', '５', '６', '７', '８', '９'];
+
+export const PERCENTAGES = ['%', '٪', '％', '﹪'];
+export const PERMILLE = ['‰', '؉'];
+
+export const UNICODE_MINUS_SIGNS = ['−', '－', '‒', '–', '—', '﹣'];
+export const UNICODE_PLUS_SIGNS = ['＋', '﹢'];
+
+export const FULLWIDTH_DECIMAL = '．';
+export const FULLWIDTH_GROUP = '，';
+
+export const ARABIC_RE = new RegExp(`[${ARABIC_NUMERALS.join('')}]`, 'g');
+export const PERSIAN_RE = new RegExp(`[${PERSIAN_NUMERALS.join('')}]`, 'g');
+export const FULLWIDTH_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join('')}]`, 'g');
+export const HAN_RE = new RegExp(`[${HAN_NUMERALS.join('')}]`, 'g');
+export const PERCENT_RE = new RegExp(`[${PERCENTAGES.join('')}]`);
+export const PERMILLE_RE = new RegExp(`[${PERMILLE.join('')}]`);
+const PERCENT_GLOBAL_RE = new RegExp(PERCENT_RE.source, 'g');
+const PERMILLE_GLOBAL_RE = new RegExp(PERMILLE_RE.source, 'g');
+
+export const ARABIC_DETECT_RE = new RegExp(`[${ARABIC_NUMERALS.join('')}]`);
+export const PERSIAN_DETECT_RE = new RegExp(`[${PERSIAN_NUMERALS.join('')}]`);
+export const HAN_DETECT_RE = new RegExp(`[${HAN_NUMERALS.join('')}]`);
+export const FULLWIDTH_DETECT_RE = new RegExp(`[${FULLWIDTH_NUMERALS.join('')}]`);
+
+export function isNumeralChar(char: string): boolean {
+	return (
+		(char >= '0' && char <= '9') ||
+		ARABIC_DETECT_RE.test(char) ||
+		PERSIAN_DETECT_RE.test(char) ||
+		HAN_DETECT_RE.test(char) ||
+		FULLWIDTH_DETECT_RE.test(char)
+	);
+}
+
+export const BASE_NON_NUMERIC_SYMBOLS = [
+	'.',
+	',',
+	FULLWIDTH_DECIMAL,
+	FULLWIDTH_GROUP,
+	'٫',
+	'٬',
+] as const;
+export const SPACE_SEPARATOR_RE = /\p{Zs}/u;
+export const PLUS_SIGNS_WITH_ASCII = ['+', ...UNICODE_PLUS_SIGNS];
+export const MINUS_SIGNS_WITH_ASCII = ['-', ...UNICODE_MINUS_SIGNS];
+
+const escapeRegExp = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeClassChar = (s: string) => s.replace(/[-\\\]^]/g, (m) => `\\${m}`);
+
+function shiftDecimal(value: number, exponentDelta: number): number {
+	const [coefficient, exponent = '0'] = String(value).split('e');
+	return Number(`${coefficient}e${Number(exponent) + exponentDelta}`);
+}
+
+const charClassFrom = (chars: string[]) => `[${chars.map(escapeClassChar).join('')}]`;
+
+const ANY_MINUS_CLASS = charClassFrom(['-'].concat(UNICODE_MINUS_SIGNS));
+const ANY_PLUS_CLASS = charClassFrom(['+'].concat(UNICODE_PLUS_SIGNS));
+
+export const ANY_MINUS_RE = new RegExp(ANY_MINUS_CLASS, 'gu');
+export const ANY_PLUS_RE = new RegExp(ANY_PLUS_CLASS, 'gu');
+export const ANY_MINUS_DETECT_RE = new RegExp(ANY_MINUS_CLASS);
+export const ANY_PLUS_DETECT_RE = new RegExp(ANY_PLUS_CLASS);
+
+export function getNumberLocaleDetails(
+	locale?: Intl.LocalesArgument,
+	options?: Intl.NumberFormatOptions,
+): Partial<Record<Intl.NumberFormatPartTypes, string | undefined>> {
+	const parts = getFormatter(locale, options).formatToParts(11111.1);
+	const result: Partial<Record<Intl.NumberFormatPartTypes, string | undefined>> = {};
+	parts.forEach((part) => {
+		result[part.type] = part.value;
+	});
+	getFormatter(locale)
+		.formatToParts(0.1)
+		.forEach((part) => {
+			if (part.type === 'decimal') {
+				result[part.type] = part.value;
+			}
+		});
+	return result;
+}
+
+export function parseNumber(
+	formattedNumber: string,
+	locale?: Intl.LocalesArgument,
+	options?: Intl.NumberFormatOptions,
+): number | null {
+	if (formattedNumber == null) {
+		return null;
+	}
+
+	let input = String(formattedNumber)
+		.replace(/\p{Cf}/gu, '')
+		.trim();
+
+	input = input.replace(ANY_MINUS_RE, '-').replace(ANY_PLUS_RE, '+');
+
+	let isNegative = false;
+
+	const trailing = input.match(/([+-])\s*$/);
+	if (trailing) {
+		if (trailing[1] === '-') {
+			isNegative = true;
+		}
+		input = input.replace(/([+-])\s*$/, '');
+	}
+	const leading = input.match(/^\s*([+-])/);
+	if (leading) {
+		if (leading[1] === '-') {
+			isNegative = true;
+		}
+		input = input.replace(/^\s*[+-]/, '');
+	}
+
+	let computedLocale = locale;
+	if (computedLocale === undefined) {
+		if (ARABIC_DETECT_RE.test(input) || PERSIAN_DETECT_RE.test(input)) {
+			computedLocale = 'ar';
+		} else if (HAN_DETECT_RE.test(input)) {
+			computedLocale = 'zh';
+		}
+	}
+
+	const { group, decimal, currency, exponentSeparator } = getNumberLocaleDetails(
+		computedLocale,
+		options,
+	);
+
+	const unitParts = getFormatter(computedLocale, options)
+		.formatToParts(1)
+		.filter((p) => p.type === 'unit')
+		.map((p) => escapeRegExp(p.value));
+	const unitRegex = unitParts.length ? new RegExp(unitParts.join('|'), 'g') : null;
+
+	let groupRegex: RegExp | null = null;
+	if (group) {
+		const isSpaceGroup = /\p{Zs}/u.test(group);
+		const isApostropheGroup = group === "'" || group === '’';
+		if (isSpaceGroup) {
+			groupRegex = /\p{Zs}/gu;
+		} else if (isApostropheGroup) {
+			groupRegex = /['’]/g;
+		} else {
+			groupRegex = new RegExp(escapeRegExp(group), 'g');
+		}
+	}
+
+	const replacements: Array<{
+		regex: RegExp | null;
+		replacement: string | ((m: string) => string);
+	}> = [
+		{ regex: groupRegex, replacement: '' },
+		{ regex: decimal ? new RegExp(escapeRegExp(decimal), 'g') : null, replacement: '.' },
+		{ regex: /．/g, replacement: '.' },
+		{ regex: /，/g, replacement: '' },
+		{ regex: /٫/g, replacement: '.' },
+		{ regex: /٬/g, replacement: '' },
+		{ regex: currency ? new RegExp(escapeRegExp(currency), 'g') : null, replacement: '' },
+		{ regex: unitRegex, replacement: '' },
+		{ regex: PERCENT_GLOBAL_RE, replacement: '' },
+		{ regex: PERMILLE_GLOBAL_RE, replacement: '' },
+		{
+			regex: exponentSeparator ? new RegExp(escapeRegExp(exponentSeparator), 'g') : null,
+			replacement: 'e',
+		},
+		{ regex: ARABIC_RE, replacement: (ch) => String(ARABIC_NUMERALS.indexOf(ch)) },
+		{ regex: PERSIAN_RE, replacement: (ch) => String(PERSIAN_NUMERALS.indexOf(ch)) },
+		{ regex: FULLWIDTH_RE, replacement: (ch) => String(FULLWIDTH_NUMERALS.indexOf(ch)) },
+		{ regex: HAN_RE, replacement: (ch) => HAN_NUMERAL_TO_DIGIT[ch] },
+	];
+
+	let unformatted = replacements.reduce((acc, { regex, replacement }) => {
+		return regex ? acc.replace(regex, replacement as any) : acc;
+	}, input);
+
+	const lastDot = unformatted.lastIndexOf('.');
+	if (lastDot !== -1) {
+		unformatted = `${unformatted.slice(0, lastDot).replace(/\./g, '')}.${unformatted.slice(lastDot + 1).replace(/\./g, '')}`;
+	}
+
+	if (/^[-+]?Infinity$/i.test(input) || input.includes('∞')) {
+		return null;
+	}
+
+	const parseTarget = (isNegative ? '-' : '') + unformatted;
+	let num = parseFloat(parseTarget);
+
+	const style = options?.style;
+	const isUnitPercent = style === 'unit' && options?.unit === 'percent';
+	const hasPercentSymbol = PERCENT_RE.test(formattedNumber) || style === 'percent';
+	const hasPermilleSymbol = PERMILLE_RE.test(formattedNumber);
+
+	if (hasPermilleSymbol) {
+		num = shiftDecimal(num, -3);
+	} else if (!isUnitPercent && hasPercentSymbol) {
+		num = shiftDecimal(num, -2);
+	}
+
+	if (!Number.isFinite(num)) {
+		return null;
+	}
+
+	return num;
+}

package/src/utils/number/types.ts

@@ -0,0 +1,25 @@
+// Ported from .base-ui/packages/react/src/number-field/utils/types.ts.
+export type Direction = -1 | 1;
+
+export type DirectionalChangeReason =
+	| 'increment-press'
+	| 'decrement-press'
+	| 'wheel'
+	| 'scrub'
+	| 'keyboard';
+
+export interface ChangeEventCustomProperties {
+	direction?: Direction;
+}
+
+export interface IncrementValueParameters {
+	direction: Direction;
+	event?: any;
+	reason: DirectionalChangeReason;
+	currentValue?: number | null;
+}
+
+export interface EventWithOptionalKeyState {
+	altKey?: boolean;
+	shiftKey?: boolean;
+}

package/src/utils/number/validate.ts

@@ -0,0 +1,129 @@
+// Ported verbatim from .base-ui/packages/react/src/number-field/utils/validate.ts. Snapping,
+// clamping, and floating-point cleanup for stepped values. Pure.
+import { clamp } from '../clamp';
+import { getFormatter } from '../formatNumber';
+import { parseNumber } from './parse';
+
+const STEP_EPSILON_FACTOR = 1e-10;
+const MAX_FLOATING_POINT_CLEANUP_DELTA = 1e-10;
+
+type NumberFormatOptionsWithRounding = Intl.NumberFormatOptions & {
+	roundingIncrement?: number;
+	roundingMode?: string;
+	roundingPriority?: string;
+};
+
+export function hasNumberFormatRoundingOptions(
+	format?: NumberFormatOptionsWithRounding,
+): format is NumberFormatOptionsWithRounding {
+	return (
+		format?.maximumFractionDigits != null ||
+		format?.minimumFractionDigits != null ||
+		format?.maximumSignificantDigits != null ||
+		format?.minimumSignificantDigits != null ||
+		format?.roundingIncrement != null ||
+		format?.roundingMode != null ||
+		format?.roundingPriority != null
+	);
+}
+
+export function removeFloatingPointErrors(
+	value: number,
+	format?: NumberFormatOptionsWithRounding,
+): number {
+	if (!Number.isFinite(value)) {
+		return value;
+	}
+
+	if (!hasNumberFormatRoundingOptions(format)) {
+		const roundedValue = parseFloat(value.toPrecision(15));
+		const cleanupDelta = Math.abs(roundedValue - value);
+		const cleanupTolerance = Math.min(
+			Number.EPSILON * Math.max(1, Math.abs(value)),
+			MAX_FLOATING_POINT_CLEANUP_DELTA,
+		);
+		return cleanupDelta <= cleanupTolerance ? roundedValue : value;
+	}
+
+	const formatter = getFormatter('en-US', {
+		...format,
+		signDisplay: 'auto',
+		currencySign: 'standard',
+		notation: format.notation === 'compact' ? 'standard' : format.notation,
+		useGrouping: false,
+	} as NumberFormatOptionsWithRounding);
+	const roundedText = formatter.format(value);
+	const roundedValue = parseNumber(roundedText, 'en-US', format);
+
+	if (roundedValue === null) {
+		return value;
+	}
+
+	return formatter.format(roundedValue) === roundedText ? roundedValue : value;
+}
+
+function snapToStep(
+	value: number,
+	base: number,
+	step: number,
+	mode: 'directional' | 'nearest' = 'directional',
+): number {
+	const stepSize = Math.abs(step);
+	const direction = Math.sign(step);
+	const tolerance = stepSize * STEP_EPSILON_FACTOR * direction;
+	const rawSteps = value - base + tolerance;
+
+	if (mode === 'nearest') {
+		return base + Math.round(rawSteps / step) * step;
+	}
+
+	const snappedSteps =
+		direction > 0 ? Math.floor(rawSteps / stepSize) : Math.ceil(rawSteps / stepSize);
+	return base + snappedSteps * stepSize;
+}
+
+export function toValidatedNumber(
+	value: number | null,
+	{
+		step,
+		minWithDefault,
+		maxWithDefault,
+		minWithZeroDefault,
+		format,
+		snapOnStep,
+		small,
+		clamp: shouldClamp,
+	}: {
+		step: number | undefined;
+		minWithDefault: number;
+		maxWithDefault: number;
+		minWithZeroDefault: number;
+		format: NumberFormatOptionsWithRounding | undefined;
+		snapOnStep: boolean;
+		small: boolean;
+		clamp: boolean;
+	},
+): number | null {
+	if (value === null) {
+		return value;
+	}
+
+	let nextValue = value;
+
+	if (step != null && snapOnStep && step !== 0) {
+		const base =
+			small || minWithDefault === Number.MIN_SAFE_INTEGER ? minWithZeroDefault : minWithDefault;
+		nextValue = snapToStep(nextValue, base, step, small ? 'nearest' : 'directional');
+	}
+
+	if (shouldClamp) {
+		nextValue = clamp(nextValue, minWithDefault, maxWithDefault);
+	}
+
+	if (step == null && !hasNumberFormatRoundingOptions(format)) {
+		return nextValue;
+	}
+
+	const roundedValue = removeFloatingPointErrors(nextValue, format);
+	return shouldClamp ? clamp(roundedValue, minWithDefault, maxWithDefault) : roundedValue;
+}

package/src/utils/owner.ts

@@ -0,0 +1,9 @@
+// Ported from .base-ui/packages/utils/src/owner.ts. `ownerWindow` resolves the window that
+// owns a node (Base UI re-exports `@floating-ui/utils/dom`'s `getWindow`).
+export function ownerWindow(node: Node | null | undefined): Window & typeof globalThis {
+	return ((node as any)?.ownerDocument?.defaultView ?? window) as Window & typeof globalThis;
+}
+
+export function ownerDocument(node: Element | null): Document {
+	return node?.ownerDocument || document;
+}

package/src/utils/platform.ts

@@ -0,0 +1,15 @@
+// Minimal port of @base-ui/utils/platform — only the `os.ios` check NumberField needs.
+// (jsdom is not iOS, so the iOS input-mode branch is inert in tests.)
+function isIOS(): boolean {
+	if (typeof navigator === 'undefined') {
+		return false;
+	}
+	return /iP(ad|hone|od)/.test(navigator.platform ?? '');
+}
+export const platform = {
+	os: {
+		get ios() {
+			return isIOS();
+		},
+	},
+};

package/src/utils/resolveAriaLabelledBy.ts

@@ -0,0 +1,11 @@
+// Ported verbatim from .base-ui/packages/react/src/utils/resolveAriaLabelledBy.ts.
+export function getDefaultLabelId(id: string | null | undefined) {
+	return id == null ? undefined : `${id}-label`;
+}
+
+export function resolveAriaLabelledBy(
+	fieldLabelId: string | undefined,
+	localLabelId: string | undefined,
+) {
+	return fieldLabelId ?? localLabelId;
+}

package/src/utils/resolveClassName.ts

@@ -0,0 +1,8 @@
+// Ported from .base-ui/packages/react/src/utils/resolveClassName.ts.
+// A className that is a function is called with the component state.
+export function resolveClassName<State>(
+	className: string | ((state: State) => string | undefined) | undefined,
+	state: State,
+): string | undefined {
+	return typeof className === 'function' ? className(state) : className;
+}

package/src/utils/resolveRef.ts

@@ -0,0 +1,10 @@
+// Ported from .base-ui/packages/react/src/utils/resolveRef.ts. Returns a ref object's
+// `.current`, or the value itself if it's already an element.
+export function resolveRef<T extends HTMLElement | null | undefined>(
+	maybeRef: T | { current: T },
+): T {
+	if (maybeRef == null) {
+		return maybeRef as T;
+	}
+	return 'current' in maybeRef ? maybeRef.current : maybeRef;
+}

package/src/utils/resolveStyle.ts

@@ -0,0 +1,10 @@
+// Ported from .base-ui/packages/react/src/utils/resolveStyle.ts.
+// A style that is a function is called with the component state.
+type CSSProperties = Record<string, any>;
+
+export function resolveStyle<State>(
+	style: CSSProperties | ((state: State) => CSSProperties | undefined) | undefined,
+	state: State,
+): CSSProperties | undefined {
+	return typeof style === 'function' ? style(state) : style;
+}

package/src/utils/serializeValue.ts

@@ -0,0 +1,15 @@
+// Ported verbatim from .base-ui/packages/react/src/internals/serializeValue.ts. Coerces a
+// control value to the string a hidden `<input value>` needs.
+export function serializeValue(value: unknown): string {
+	if (value == null) {
+		return '';
+	}
+	if (typeof value === 'string') {
+		return value;
+	}
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}

package/src/utils/slider/asc.ts

@@ -0,0 +1,4 @@
+// Ported verbatim from .base-ui/packages/react/src/slider/utils/asc.ts.
+export function asc(a: number, b: number) {
+	return a - b;
+}